OS Core Concepts Complete Guide: Everything About Operating Systems for Developer Interviews

┌─────────────────────────────────┐
│         PCB (Process            │
│         Control Block)          │
├─────────────────────────────────┤
│  Process ID (PID)               │
│  Process State                  │
│  Program Counter (PC)           │
│  CPU Registers                  │
│  CPU Scheduling Info            │
│  Memory Management Info         │
│  I/O Status Info                │
│  Accounting Info                │
└─────────────────────────────────┘

         ┌──────────┐
    New   │          │  Terminated
  ──────▶│  Ready   │──────▶
         │          │
         └────┬─────┘
              │ dispatch
              ▼
         ┌──────────┐     I/O request
         │ Running  │───────────┐
         │          │           │
         └────┬─────┘           ▼
              │           ┌──────────┐
   Preempt   │           │ Waiting  │
              │           │ (Blocked)│
              └───────────┤          │
                          └──────────┘
                     I/O complete -> Ready

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

int main() {
    pid_t pid = fork();  // Duplicate process

    if (pid < 0) {
        perror("fork failed");
        return 1;
    } else if (pid == 0) {
        // Child process
        printf("Child PID: %d, Parent PID: %d\n", getpid(), getppid());
        execlp("ls", "ls", "-la", NULL);
        perror("exec failed");
    } else {
        // Parent process
        printf("Parent PID: %d, Child PID: %d\n", getpid(), pid);
        int status;
        waitpid(pid, &status, 0);
        printf("Child exited with status: %d\n", WEXITSTATUS(status));
    }
    return 0;
}

// Shared Memory example
#include <sys/mman.h>
#include <fcntl.h>
#include <string.h>

int main() {
    const char *name = "/my_shm";
    const int SIZE = 4096;

    // Create shared memory object
    int fd = shm_open(name, O_CREAT | O_RDWR, 0666);
    ftruncate(fd, SIZE);

    // Memory mapping
    void *ptr = mmap(0, SIZE, PROT_WRITE, MAP_SHARED, fd, 0);
    memcpy(ptr, "Hello from producer!", 20);

    // Cleanup: munmap, shm_unlink
    return 0;
}

Process A                Process B
┌───────────────┐        ┌───────────────┐
│ Code  │ Data  │        │ Code  │ Data  │
│───────│───────│        │───────│───────│
│ Heap  │ Stack │        │ Heap  │ Stack │
│       │ (main)│        │       │ (main)│
└───────────────┘        └───────────────┘
  Independent memory       Independent memory

Process C (multi-threaded)
┌───────────────────────────────┐
│ Code (shared) │ Data (shared) │
│───────────────│───────────────│
│ Heap (shared) │ Stack1│Stack2 │
│               │ (T1)  │(T2)  │
└───────────────────────────────┘
  Threads share Code, Data, Heap
  Each thread has its own Stack

#include <pthread.h>
#include <stdio.h>

#define NUM_THREADS 4

typedef struct {
    int thread_id;
    int start;
    int end;
    long result;
} ThreadArg;

void* sum_range(void* arg) {
    ThreadArg* targ = (ThreadArg*)arg;
    targ->result = 0;
    for (int i = targ->start; i <= targ->end; i++) {
        targ->result += i;
    }
    printf("Thread %d: sum(%d..%d) = %ld\n",
           targ->thread_id, targ->start, targ->end, targ->result);
    return NULL;
}

int main() {
    pthread_t threads[NUM_THREADS];
    ThreadArg args[NUM_THREADS];
    int range_per_thread = 250;

    for (int i = 0; i < NUM_THREADS; i++) {
        args[i].thread_id = i;
        args[i].start = i * range_per_thread + 1;
        args[i].end = (i + 1) * range_per_thread;
        pthread_create(&threads[i], NULL, sum_range, &args[i]);
    }

    long total = 0;
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
        total += args[i].result;
    }

    printf("Total sum: %ld\n", total);  // 500500
    return 0;
}

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    results := make(chan int, 4)

    for i := 0; i < 4; i++ {
        wg.Add(1)
        go func(id, start, end int) {
            defer wg.Done()
            sum := 0
            for j := start; j <= end; j++ {
                sum += j
            }
            results <- sum
            fmt.Printf("Goroutine %d: sum(%d..%d) = %d\n", id, start, end, sum)
        }(i, i*250+1, (i+1)*250)
    }

    go func() {
        wg.Wait()
        close(results)
    }()

    total := 0
    for r := range results {
        total += r
    }
    fmt.Printf("Total: %d\n", total)
}

import threading
import multiprocessing
import time

# CPU-bound work: threads offer no benefit due to GIL
def cpu_bound(n):
    total = 0
    for i in range(n):
        total += i * i
    return total

# Thread approach (GIL-limited)
def thread_test():
    threads = [threading.Thread(target=cpu_bound, args=(10_000_000,))
               for _ in range(4)]
    start = time.time()
    for t in threads:
        t.start()
    for t in threads:
        t.join()
    print(f"Threads: {time.time() - start:.2f}s")

# Process approach (bypasses GIL)
def process_test():
    processes = [multiprocessing.Process(target=cpu_bound, args=(10_000_000,))
                 for _ in range(4)]
    start = time.time()
    for p in processes:
        p.start()
    for p in processes:
        p.join()
    print(f"Processes: {time.time() - start:.2f}s")

# I/O-bound: threads are effective
# CPU-bound: use multiprocessing or C extensions

# Adjust process priority with nice values (-20 to +19)
nice -n 10 ./my_program        # Run with lower priority
renice -n -5 -p 1234          # Raise priority of PID 1234

# Set real-time scheduling policy
chrt -f 50 ./realtime_program   # FIFO, priority 50
chrt -r 50 ./realtime_program   # Round Robin, priority 50

# Limit CPU usage with cgroups v2
mkdir /sys/fs/cgroup/my_group

# CPU bandwidth limit: max 25ms per 50ms period (50%)
echo "25000 50000" > /sys/fs/cgroup/my_group/cpu.max

# Add process to cgroup
echo 1234 > /sys/fs/cgroup/my_group/cgroup.procs

# CPU weight (default 100, range 1-10000)
echo 200 > /sys/fs/cgroup/my_group/cpu.weight

// Race condition example — counter without synchronization
#include <pthread.h>
#include <stdio.h>

int counter = 0;  // Shared variable

void* increment(void* arg) {
    for (int i = 0; i < 1000000; i++) {
        counter++;  // Not atomic! (read -> modify -> write)
    }
    return NULL;
}

int main() {
    pthread_t t1, t2;
    pthread_create(&t1, NULL, increment, NULL);
    pthread_create(&t2, NULL, increment, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    printf("Counter: %d (expected 2000000)\n", counter);
    // Actually outputs less than 2000000
    return 0;
}

#include <pthread.h>
#include <stdio.h>

pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
int counter = 0;

void* safe_increment(void* arg) {
    for (int i = 0; i < 1000000; i++) {
        pthread_mutex_lock(&lock);     // Acquire lock
        counter++;                      // Critical section
        pthread_mutex_unlock(&lock);   // Release lock
    }
    return NULL;
}

int main() {
    pthread_t t1, t2;
    pthread_create(&t1, NULL, safe_increment, NULL);
    pthread_create(&t2, NULL, safe_increment, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    printf("Counter: %d\n", counter);  // Exactly 2000000
    return 0;
}

#include <semaphore.h>
#include <pthread.h>
#include <stdio.h>

sem_t semaphore;

void* worker(void* arg) {
    int id = *(int*)arg;
    printf("Thread %d waiting...\n", id);
    sem_wait(&semaphore);     // Decrement, wait if 0
    printf("Thread %d entered critical section\n", id);
    sleep(2);
    printf("Thread %d leaving\n", id);
    sem_post(&semaphore);     // Increment
    return NULL;
}

int main() {
    sem_init(&semaphore, 0, 3);  // Allow 3 concurrent threads

    pthread_t threads[10];
    int ids[10];
    for (int i = 0; i < 10; i++) {
        ids[i] = i;
        pthread_create(&threads[i], NULL, worker, &ids[i]);
    }
    for (int i = 0; i < 10; i++) {
        pthread_join(threads[i], NULL);
    }
    sem_destroy(&semaphore);
    return 0;
}

  Thread A              Thread B
  ┌──────┐             ┌──────┐
  │Lock X│────wait────▶│Lock Y│
  │held  │             │held  │
  └──────┘◀────wait────└──────┘

import threading
import time

lock_a = threading.Lock()
lock_b = threading.Lock()

def thread_1():
    lock_a.acquire()
    time.sleep(0.1)
    lock_b.acquire()  # Deadlock! Thread 2 holds lock_b
    lock_b.release()
    lock_a.release()

def thread_2():
    lock_b.acquire()
    time.sleep(0.1)
    lock_a.acquire()  # Deadlock! Thread 1 holds lock_a
    lock_a.release()
    lock_b.release()

t1 = threading.Thread(target=thread_1)
t2 = threading.Thread(target=thread_2)
t1.start()
t2.start()

# Remove circular wait: enforce lock ordering
def safe_thread_1():
    lock_a.acquire()   # Always lock_a first
    lock_b.acquire()
    # ... work ...
    lock_b.release()
    lock_a.release()

def safe_thread_2():
    lock_a.acquire()   # Always lock_a first (same order)
    lock_b.acquire()
    # ... work ...
    lock_b.release()
    lock_a.release()

┌────────────────────┐  Speed: Very fast
│    CPU Registers   │  Capacity: Several KB
├────────────────────┤
│    L1 Cache        │  ~1ns, 64KB
├────────────────────┤
│    L2 Cache        │  ~4ns, 256KB
├────────────────────┤
│    L3 Cache        │  ~12ns, Several MB
├────────────────────┤
│    Main Memory     │  ~100ns, Several GB
│    (DRAM)          │
├────────────────────┤
│    SSD             │  ~100us, Several TB
├────────────────────┤  Speed: Very slow
│    HDD             │  ~10ms, Several TB
└────────────────────┘

Logical Address Space        Physical Memory
┌───────────┐              ┌───────────┐
│  Page 0   │──────────▶  │  Frame 3  │
├───────────┤              ├───────────┤
│  Page 1   │──────────▶  │  Frame 7  │
├───────────┤              ├───────────┤
│  Page 2   │──────────▶  │  Frame 1  │
├───────────┤              ├───────────┤
│  Page 3   │──────────▶  │  Frame 5  │
└───────────┘              └───────────┘

1. CPU accesses a logical address
2. Check valid bit in page table
3. Not valid -> Page fault interrupt
4. OS finds the page on disk
5. Allocate free frame (page replacement if none)
6. Load from disk to frame
7. Update page table (valid bit = 1)
8. Restart interrupted instruction

┌─────────────────────────────┐
│           inode              │
├─────────────────────────────┤
│ File type (regular, dir...) │
│ Permissions (rwxrwxrwx)     │
│ Owner (UID, GID)            │
│ File size                    │
│ Timestamps (atime,mtime,ctime)│
│ Link count                   │
├─────────────────────────────┤
│ Direct Blocks (12)          │ -> Data blocks
│ Single Indirect Block       │ -> Pointer block -> Data
│ Double Indirect Block       │ -> Pointer -> Pointer -> Data
│ Triple Indirect Block       │ -> 3-level indirect
└─────────────────────────────┘

User Program
    |
    v
VFS (Virtual File System)
    |
    +-->  ext4
    +-->  XFS
    +-->  NFS (network)
    +-->  procfs (/proc)
    +-->  sysfs (/sys)

// Blocking I/O -- read() blocks until data arrives
char buf[1024];
int n = read(fd, buf, sizeof(buf));  // Blocking!

// Non-blocking I/O
int flags = fcntl(fd, F_GETFL, 0);
fcntl(fd, F_SETFL, flags | O_NONBLOCK);
int n = read(fd, buf, sizeof(buf));
if (n == -1 && errno == EAGAIN) {
    // No data available, try again later
}

#include <sys/epoll.h>

int epoll_fd = epoll_create1(0);

struct epoll_event ev;
ev.events = EPOLLIN | EPOLLET;  // Edge-Triggered
ev.data.fd = listen_fd;
epoll_ctl(epoll_fd, EPOLL_CTL_ADD, listen_fd, &ev);

struct epoll_event events[MAX_EVENTS];
while (1) {
    int nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
    for (int i = 0; i < nfds; i++) {
        if (events[i].data.fd == listen_fd) {
            int conn_fd = accept(listen_fd, ...);
            // Register conn_fd with epoll too
        } else {
            handle_client(events[i].data.fd);
        }
    }
}

Traditional approach (4 copies):
Disk -> Kernel Buffer -> User Buffer -> Socket Buffer -> NIC

Zero-Copy (sendfile):
Disk -> Kernel Buffer -> NIC (2 or fewer copies)

#include <sys/sendfile.h>
// Send file directly to socket (no user space copy)
sendfile(socket_fd, file_fd, NULL, file_size);

User Program
    |
    |  write(fd, buf, count)
    v
+-------------------+
|  C Library        |  <- glibc write() wrapper
|  (glibc)          |
+--------+----------+
         | syscall instruction
         v
+-------------------+
|  Kernel Space     |  <- sys_write() kernel function
+-------------------+

# Trace system calls of a process
strace -p 1234

# Filter specific system calls
strace -e trace=open,read,write ./my_program

# Include timing info
strace -T -e trace=network ./my_server

# Summary statistics
strace -c ./my_program

# CPU profiling
perf record -g ./my_program
perf report

# Check cache misses
perf stat -e cache-misses,cache-references ./my_program

# Count specific events
perf stat -e context-switches,cpu-migrations ./my_program

# Simple eBPF with bpftrace

# Count all system calls
bpftrace -e 'tracepoint:raw_syscalls:sys_enter { @[comm] = count(); }'

# Trace file opens per process
bpftrace -e 'tracepoint:syscalls:sys_enter_openat {
    printf("%s opened %s\n", comm, str(args->filename));
}'

# Run shell in new PID namespace
sudo unshare --pid --mount-proc --fork /bin/bash
# ps aux in this shell shows only isolated processes

# Docker cgroups resource limits
docker run --cpus="0.5"           # CPU 50% limit
docker run --memory="512m"        # Memory 512MB limit
docker run --pids-limit=100       # Max 100 processes

Container Layer (read/write)
    |
    v
+---------------------+
|   OverlayFS         |
|   (merged view)     |
+---------------------+
    |         |
    v         v
Image Layer 3  Image Layer 2  Image Layer 1 (read-only)
(app code)     (dependencies)  (base OS)