1. Save current task's registers to its task_struct
2. Save stack pointer
3. Select next task (scheduler)
4. Restore next task's stack pointer
5. Restore next task's registers
6. If different process: switch page tables (TLB flush)
7. Return to user mode

Virtual Address → MMU → Page Tables → Physical Address

┌────────────────┐     ┌─────────────────┐     ┌────────────────┐
│ Process A      │     │   Page Table A  │     │ Physical RAM   │
│ addr: 0x1000   │────►│ 0x1→phy 0x8000 │────►│ Frame 0x8000   │
└────────────────┘     └─────────────────┘     └────────────────┘

┌────────────────┐     ┌─────────────────┐     
│ Process B      │     │   Page Table B  │     Same physical
│ addr: 0x1000   │────►│ 0x1→phy 0x9000 │────►frame or different
└────────────────┘     └─────────────────┘     

1. CPU accesses address
2. MMU checks page table → entry invalid/not present
3. CPU raises page fault exception
4. Kernel handler runs:
   - Find VMA for address
   - Check permissions
   - If valid:
     - Minor: Update page table
     - Major: Read from disk, then update
   - If invalid: SIGSEGV
5. Return to faulting instruction (retry)

malloc(100)           ← User request
     │
     ▼
User allocator        ← glibc (ptmalloc/jemalloc)
(maintains free list, caches)
     │
     ▼ brk()/mmap() if needed
Kernel
(VMA management, demand paging)

// BAD: Thread 1 locks A then B, Thread 2 locks B then A

// GOOD: Always lock in order (A before B)
void transfer(Account *from, Account *to) {
    Account *first = (from < to) ? from : to;
    Account *second = (from < to) ? to : from;
    lock(first);
    lock(second);
    // transfer...
    unlock(second);
    unlock(first);
}

pthread_mutex_lock(&mutex);
// Critical section - only one thread
pthread_mutex_unlock(&mutex);

sem_wait(&sem);  // Decrement, block if 0
// Access resource (up to N concurrent)
sem_post(&sem);  // Increment

pthread_mutex_lock(&mutex);
while (!condition) {
    pthread_cond_wait(&cond, &mutex);  // Releases mutex while waiting
}
// Condition is now true
pthread_mutex_unlock(&mutex);

// In another thread:
pthread_mutex_lock(&mutex);
condition = true;
pthread_cond_signal(&cond);  // Wake one waiter
pthread_mutex_unlock(&mutex);

while (atomic_test_and_set(&lock) == 1) {
    // Spin! CPU is busy waiting
}
// Have lock
// ... critical section ...
atomic_clear(&lock);

Low priority task (L) holds lock
High priority task (H) needs lock → blocks
Medium priority task (M) preempts L

Result: H waits for M, even though H > M priority!

read(fd, buffer, size)
     │
     ▼
VFS (Virtual File System)
- Translates to inode operations
     │
     ▼
Page Cache (Check if cached)
─────► HIT: Copy to user buffer, return
─────► MISS: Continue...
     │
     ▼
Filesystem (ext4, xfs)
- Map file offset → block numbers
     │
     ▼
Block Layer
- I/O scheduling, merging
     │
     ▼
Device Driver
- Issue commands to disk
     │
     ▼
Hardware (SSD/HDD)
- DMA data to memory
     │
     ▼
Complete I/O
- Wake up process
- Copy to user buffer

// Process blocks until I/O completes
ssize_t n = read(fd, buffer, size);
// Control returns here after disk I/O

// Submit request, continue immediately
struct aiocb cb = {...};
aio_read(&cb);
// Do other work...
// Later: check completion or get signal

// Submit multiple I/O requests
io_uring_prep_read(sqe, fd, buffer, size, offset);
io_uring_submit(&ring);

// Check completions (batched)
io_uring_wait_cqe(&ring, &cqe);

fd_set readfds;
FD_ZERO(&readfds);
FD_SET(fd, &readfds);
select(fd+1, &readfds, NULL, NULL, NULL);
if (FD_ISSET(fd, &readfds)) { ... }

struct pollfd fds[1];
fds[0].fd = fd;
fds[0].events = POLLIN;
poll(fds, 1, -1);
if (fds[0].revents & POLLIN) { ... }

int epfd = epoll_create1(0);
struct epoll_event ev = {.events = EPOLLIN, .data.fd = fd};
epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev);

struct epoll_event events[10];
int n = epoll_wait(epfd, events, 10, -1);
// Only returns ready FDs!

// Create new namespace
clone(..., CLONE_NEWPID | CLONE_NEWNET, ...);

// Or join existing
setns(fd, CLONE_NEWPID);

# Create cgroup
mkdir /sys/fs/cgroup/memory/mycontainer
echo 100M > /sys/fs/cgroup/memory/mycontainer/memory.max
echo $$ > /sys/fs/cgroup/memory/mycontainer/cgroup.procs

typedef struct {
    pthread_t *threads;
    int num_threads;
    
    // Task queue
    task_t *queue;
    int head, tail;
    int queue_size;
    
    // Synchronization
    pthread_mutex_t lock;
    pthread_cond_t not_empty;
    pthread_cond_t not_full;
    
    bool shutdown;
} thread_pool_t;

void *worker(void *arg) {
    thread_pool_t *pool = arg;
    
    while (1) {
        pthread_mutex_lock(&pool->lock);
        
        while (pool->head == pool->tail && !pool->shutdown) {
            pthread_cond_wait(&pool->not_empty, &pool->lock);
        }
        
        if (pool->shutdown) {
            pthread_mutex_unlock(&pool->lock);
            break;
        }
        
        task_t task = pool->queue[pool->head];
        pool->head = (pool->head + 1) % pool->queue_size;
        
        pthread_cond_signal(&pool->not_full);
        pthread_mutex_unlock(&pool->lock);
        
        // Execute task
        task.func(task.arg);
    }
    return NULL;
}

void submit(thread_pool_t *pool, void (*func)(void*), void *arg) {
    pthread_mutex_lock(&pool->lock);
    
    while ((pool->tail + 1) % pool->queue_size == pool->head) {
        pthread_cond_wait(&pool->not_full, &pool->lock);
    }
    
    pool->queue[pool->tail] = (task_t){func, arg};
    pool->tail = (pool->tail + 1) % pool->queue_size;
    
    pthread_cond_signal(&pool->not_empty);
    pthread_mutex_unlock(&pool->lock);
}

typedef struct {
    void *base;
    size_t size;
    size_t offset;
} arena_t;

void *arena_alloc(arena_t *arena, size_t size) {
    // Align to 8 bytes
    size = (size + 7) & ~7;
    
    if (arena->offset + size > arena->size) {
        return NULL;
    }
    
    void *ptr = (char*)arena->base + arena->offset;
    arena->offset += size;
    return ptr;
}

void arena_reset(arena_t *arena) {
    arena->offset = 0;
}

typedef struct block {
    size_t size;
    struct block *next;
} block_t;

block_t *free_list = NULL;

void *my_malloc(size_t size) {
    block_t **prev = &free_list;
    block_t *curr = free_list;
    
    // First fit
    while (curr) {
        if (curr->size >= size) {
            *prev = curr->next;
            return (char*)curr + sizeof(block_t);
        }
        prev = &curr->next;
        curr = curr->next;
    }
    
    // No fit, get from OS
    block_t *new = sbrk(size + sizeof(block_t));
    new->size = size;
    return (char*)new + sizeof(block_t);
}

void my_free(void *ptr) {
    block_t *block = (block_t*)((char*)ptr - sizeof(block_t));
    block->next = free_list;
    free_list = block;
}

typedef struct {
    double tokens;
    double max_tokens;
    double refill_rate;  // tokens per second
    struct timespec last_refill;
    pthread_mutex_t lock;
} rate_limiter_t;

bool acquire(rate_limiter_t *rl, double tokens) {
    pthread_mutex_lock(&rl->lock);
    
    // Refill tokens based on elapsed time
    struct timespec now;
    clock_gettime(CLOCK_MONOTONIC, &now);
    
    double elapsed = (now.tv_sec - rl->last_refill.tv_sec) +
                    (now.tv_nsec - rl->last_refill.tv_nsec) / 1e9;
    
    rl->tokens += elapsed * rl->refill_rate;
    if (rl->tokens > rl->max_tokens) {
        rl->tokens = rl->max_tokens;
    }
    rl->last_refill = now;
    
    // Try to acquire
    if (rl->tokens >= tokens) {
        rl->tokens -= tokens;
        pthread_mutex_unlock(&rl->lock);
        return true;
    }
    
    pthread_mutex_unlock(&rl->lock);
    return false;
}

// Track requests in time window
// More accurate for bursts but more memory
typedef struct {
    int *requests;      // Circular buffer
    int window_size;    // Seconds
    int max_requests;
    struct timespec window_start;
} sliding_window_t;