OS Interview Questions

A program is a passive file on disk; a process is that program in execution — with its own address space (code, data, heap, stack), registers, program counter, and a PCB the kernel tracks it with.

A process is an isolated execution environment with its own address space; a thread is a lighter unit of execution inside a process that shares the address space but keeps its own stack and registers.

The kernel’s per-process bookkeeping record: PID, state, saved registers, memory map, open file descriptors, scheduling info. Context switches save into and restore from it.

New (being created), Ready (waiting for CPU), Running (on the CPU), Waiting (blocked on I/O or an event), Terminated (finished, awaiting cleanup). The scheduler cycles Ready ⇄ Running.

A controlled entry point into the kernel for privileged work (file I/O, process creation, networking). User mode can’t touch hardware or other processes’ memory; the mode split is what makes isolation and security enforceable.

Preemptive: the OS can interrupt a running process when its time slice expires or a higher-priority task arrives. Non-preemptive: a process runs until it yields or blocks. All modern general-purpose OSes are preemptive.

An abstraction giving each process its own private address space, mapped to physical frames by page tables. Enables isolation, overcommit (more virtual than RAM, spilling to disk), and shared pages like libraries.

A trap raised when a process touches a virtual page with no valid mapping. Minor: the page is in memory, just not mapped — fix the table. Major: load it from disk. Invalid: segfault.

A mutex is a lock with ownership — one holder, who must release it. A counting semaphore is a counter for N permits with wait/signal, no ownership — usable for signaling between threads, not just mutual exclusion.

fork() clones the caller. Execution resumes in both processes from the same point, so the one call returns in each: 0 in the child, the child’s PID in the parent — that return value is how the code tells them apart.

Zombie: child exited but the parent hasn’t wait()ed — the dead entry lingers holding its exit status. Orphan: parent died first — the child is re-parented to init/systemd, which reaps it. Fix zombies by handling SIGCHLD or double-forking.

Saving/restoring registers and the PC, switching page tables for a different process, and — the hidden cost — flushed TLB entries and cold CPU caches afterwards. Thread switches within a process skip the address-space swap, so they’re cheaper.

Too small: context-switch overhead dominates — throughput collapses. Too large: it degrades into FCFS and interactive latency dies. Rule of thumb: quantum much larger than switch cost, small enough to feel responsive (~ms range).

You can’t know burst lengths in advance, and long jobs starve while short ones keep jumping ahead. Real schedulers approximate it: MLFQ demotes CPU hogs, favoring short interactive bursts — SJF behavior without the crystal ball.

Paging chops memory into fixed-size pages — no external fragmentation, hardware-friendly, what everything uses. Segmentation uses variable-size logical units (code/heap/stack) — matches program structure but fragments; modern OSes are page-based.

It caches virtual→physical translations so hits skip the page-table walk. A miss means walking a multi-level page table (several memory reads); the result is cached. This is why locality matters and why context switches hurt.

The system spends more time servicing page faults than doing work — working sets exceed RAM, every process steals frames from the others. Signature: CPU utilization drops while disk I/O saturates. Fix: fewer processes, more RAM, or better locality.

Race: correctness depends on the interleaving of concurrent accesses to shared state. Critical section: the code touching that shared state, which must execute mutually exclusively — guarded by a mutex or made atomic.

Three primitives: empty counting free slots (init N), full counting filled (init 0), a mutex over the buffer. Producer: wait(empty), lock, insert, unlock, signal(full). Consumer mirrors it. Ordering of waits matters — swap them and you deadlock.

Mutual exclusion, hold-and-wait, no preemption, circular wait — all four must hold simultaneously. Break any one and deadlock is impossible; the practical one is circular wait, via global lock ordering.

Prevention: structurally break a Coffman condition (lock ordering). Avoidance: consider requests at runtime, grant only if the state stays safe (Banker’s). Detection: let it happen, find cycles in the wait-for graph, kill a victim — what databases do.

The inode holds a file’s metadata and block pointers — everything except its name. Hard link: another directory entry pointing at the same inode (equal peer, survives deleting the original). Symlink: a small file containing a path — can dangle, can cross filesystems.

Corruption from crashes mid-update. Changes are written to a journal first, then applied; on reboot, replay or discard incomplete transactions. Metadata journaling (default ext4) protects structure; full-data journaling protects contents at a write-amplification cost.

fork() doesn’t copy memory — parent and child share all pages, marked read-only. Only when either writes does the kernel trap and copy that single page. fork+exec is nearly free since exec replaces the image anyway.

Grant a resource request only if, assuming every process may still demand its declared maximum, there exists some order in which all can finish — a “safe state”. If granting would leave no such order, block the request. Requires declared maximums, so it’s rarely used outside coursework.

select scans the whole fd set every call: O(n) per event, plus copying the set in and out of the kernel. epoll registers interest once; the kernel pushes ready fds to a queue — O(1) per event regardless of connection count. That’s the C10k answer.

DMA lets devices move data to/from RAM without the CPU copying byte-by-byte — the CPU sets up the transfer and gets one interrupt on completion. At high packet rates even that is too many interrupts, so NICs batch: one interrupt per group of packets (NAPI/polling hybrids).

A low-priority thread holds a lock a high-priority thread needs, while medium-priority threads starve the low one — so the high-priority thread waits on the medium ones. Fix: priority inheritance — the lock holder temporarily gets the waiter’s priority. Famously hit the Mars Pathfinder.

Firmware (UEFI) POSTs and loads the bootloader from the EFI partition → bootloader (GRUB) loads kernel + initramfs → kernel initializes hardware, mounts root, starts PID 1 → init/systemd brings up services in dependency order → getty/display manager → login → your shell. Know which stage to blame when boot hangs.

Pool size (CPU-bound: ~cores; I/O-bound: larger, or work-stealing), a bounded task queue (unbounded queues hide overload — prefer backpressure or rejection policy), shutdown semantics (drain vs abort), and avoiding deadlock from tasks that submit and wait on other tasks in the same pool.