50 Operating System Interview Questions (With Answers)

Operating system interviews test your understanding of how hardware and software interact — from process scheduling and memory allocation to deadlock prevention and file systems. This guide covers the 50 most common OS questions with concise, accurate answers.

Quick reference

Processes and Threads

1. What is a process? How does it differ from a program?

A program is a passive set of instructions stored on disk. A process is a running instance of a program — it includes:

• Program code (text segment)
• Stack (function calls, local variables)
• Heap (dynamically allocated memory)
• Data segment (global/static variables)
• Process Control Block (PCB) — OS metadata

You can run the same program as multiple processes simultaneously (e.g., two terminal windows running bash).

2. What is a Process Control Block (PCB)?

The PCB is the OS data structure that stores all information about a process:

3. What are the process states?

        fork()
          |
       [New] ──────────────────────────────────────────────►
          |           admitted                              
       [Ready] ◄──────────────────── [Waiting]             
          |       I/O complete/event |                     
     scheduled                      | I/O or event wait   
          |                         |                     
       [Running] ──────────────────►                       
          |       interrupt (preempt) ──► [Ready]          
          |       exit
       [Terminated]

4. What is a thread? How does it differ from a process?

A thread is the smallest unit of CPU execution within a process. Multiple threads share the same process address space.

5. What is context switching?

Context switching is the OS saving the state of the current process/thread and restoring another's state so the CPU can run a different process.

Steps:

1. Save running process's registers → PCB
2. Update PCB state (Running → Ready or Waiting)
3. Choose next process (scheduler)
4. Load new process's registers from its PCB
5. Update memory mappings (flush TLB if different process)
6. Resume execution at saved program counter

Cost: Pure overhead — no useful work done. Minimised with thread pools and cooperative scheduling.

6. What is the difference between fork() and exec()?

7. What is a zombie process? A daemon?

Zombie process: A process that has finished executing but its entry remains in the process table because the parent hasn't called wait() yet. The OS holds exit status until parent reads it.

# View zombies
ps aux | grep Z

Daemon: A background process that runs without a controlling terminal (e.g., sshd, cron). Created by double-forking and closing stdin/stdout/stderr.

8. What is inter-process communication (IPC)?

IPC mechanisms for processes to exchange data:

9. What is the difference between user mode and kernel mode?

Transition happens via system calls (software interrupt, syscall instruction) — the only safe gateway from user to kernel mode.

10. What is a system call?

A system call is the interface between a user-space program and the OS kernel. When a process needs a privileged operation:

1. User program calls library function (e.g., read())
2. Library puts arguments in registers, executes syscall instruction
3. CPU switches to kernel mode, jumps to syscall handler
4. Kernel performs operation (validates permissions, accesses hardware)
5. Returns result, CPU switches back to user mode

Examples: open, read, write, close, fork, exec, mmap, socket, exit.

CPU Scheduling

11. What is CPU scheduling? Why is it needed?

CPU scheduling determines which ready process/thread gets the CPU next. Needed because CPU is a scarce resource and multiple processes compete for it.

Goals:

• Maximise CPU utilisation
• Maximise throughput (processes completed per unit time)
• Minimise turnaround time (submission to completion)
• Minimise waiting time (time in ready queue)
• Minimise response time (first response)
• Fairness

12. What are the main CPU scheduling algorithms?

13. What is the difference between preemptive and non-preemptive scheduling?

14. What is Round Robin scheduling? How do you choose the quantum?

Round Robin (RR): Each process gets a fixed time quantum (e.g., 10–100ms). If not done, it's preempted and added to the back of the ready queue.

Quantum selection:

• Too small: Excessive context switching overhead
• Too large: Degenerates to FCFS
• Rule of thumb: 80% of CPU bursts should be shorter than the quantum

15. What is the Multilevel Feedback Queue (MLFQ)?

MLFQ has multiple queues with decreasing priority. New processes start at the highest-priority queue (shortest quantum). If a process uses its full quantum, it's demoted to a lower queue (longer quantum). I/O-bound processes that give up CPU early stay at high priority.

Solves starvation with periodic priority boost — move all processes to the top queue after some time interval.

Synchronization and Deadlocks

16. What is a race condition?

A race condition occurs when two or more processes access shared data concurrently and the final result depends on the execution order. The shared section where this can happen is the critical section.

Thread A: balance = balance + 100   (reads 500, adds 100)
Thread B: balance = balance - 200   (reads 500, subtracts 200)
Result: 600 or 300 — depends on timing. Correct: 400.

17. What are the requirements for a critical section solution?

Any solution to the critical section problem must satisfy:

1. Mutual exclusion: Only one process in the critical section at a time
2. Progress: If no process is in the critical section, a process that wants to enter must be able to (no indefinite postponement)
3. Bounded waiting: A limit exists on the number of times other processes can enter before a waiting process is allowed in

18. What is a mutex? A semaphore? How do they differ?

Mutex example:

pthread_mutex_lock(&mutex);
// critical section
pthread_mutex_unlock(&mutex);

Semaphore operations:

• wait(S) / P(S): Decrement S; if S < 0, block
• signal(S) / V(S): Increment S; wake a blocked process

19. What is a monitor?

A monitor is a higher-level synchronization construct (built into languages like Java):

• Only one thread executes inside the monitor at a time
• Condition variables: wait() releases the lock and blocks; notify()/notifyAll() wakes waiting threads
• Prevents many common mutex mistakes (forgetting to unlock, signaling wrong condition)

synchronized (lock) {
    while (!condition) lock.wait();
    // critical section
    lock.notifyAll();
}

20. What are the four necessary conditions for deadlock?

All four must hold simultaneously:

21. How can deadlocks be handled?

22. Explain the Banker's Algorithm.

The Banker's Algorithm (Dijkstra) prevents deadlock by checking if a resource grant leaves the system in a safe state — one where every process can eventually complete in some order.

State: n processes, m resource types
For each request:
  1. Check request ≤ need[i] (no over-requesting)
  2. Check request ≤ available (resources exist)
  3. Tentatively allocate
  4. Run safety algorithm:
     - Find process whose need ≤ available
     - Simulate completion, release resources
     - Repeat until all done (safe) or stuck (unsafe)
  5. If safe → grant; if unsafe → make process wait

23. What is the difference between starvation and deadlock?

24. What is a spinlock?

A spinlock is a busy-waiting lock: the thread continuously checks (spins) if the lock is free instead of blocking.

Pros: No context switch overhead; fast if lock is held briefly
Cons: Wastes CPU cycles; bad when lock held for long duration
Use case: Kernel code where sleeping is not allowed; multi-core systems with short critical sections

Memory Management

25. What is memory management? What are its goals?

Memory management is the OS function of allocating, tracking, and reclaiming RAM.

Goals:

• Allocate memory to processes
• Protect one process's memory from others
• Allow more processes than physical RAM (virtual memory)
• Efficient space utilisation (avoid fragmentation)

26. What is the difference between contiguous and non-contiguous memory allocation?

Fragmentation types:

• Internal: Allocated block larger than needed (wasted inside block)
• External: Enough total free space but not contiguous

27. What is paging?

Paging divides:

• Physical memory into fixed-size frames
• Process virtual address space into same-size pages

OS maintains a page table per process mapping page numbers to frame numbers.

Virtual address: [page number | offset]
Physical address: [frame number | offset]
                   ^ from page table

Benefits: Eliminates external fragmentation; enables non-contiguous allocation.

28. What is segmentation?

Segmentation divides a process's address space into logical units (segments: code, data, stack, heap) of variable size.

Each segment has a base (physical start address) and limit (size).

Comparison:

Many architectures combine both (segmented paging).

29. What is virtual memory?

Virtual memory allows processes to use more memory than physical RAM by storing inactive pages on disk (swap space).

Each process sees a large, contiguous virtual address space. The OS transparently moves pages between RAM and disk.

Benefits:

• Run programs larger than RAM
• More processes in memory simultaneously
• Memory isolation between processes

Cost: Disk access is ~1000× slower than RAM — excessive paging causes thrashing.

30. What is a TLB (Translation Lookaside Buffer)?

The TLB is a hardware cache for page table entries, located in the CPU.

Without TLB: every memory access = 2+ memory accesses (page table lookup + actual data).
With TLB: most accesses = 1 memory access (TLB hit).

TLB miss: Hardware (or OS) walks the page table and loads the entry into TLB.
TLB flush: On context switch to a different process (different page table) — all TLB entries invalidated (or tagged with Address Space IDs/ASIDs to avoid full flush).

Typical TLB hit rate: 95–99% → effective memory access time ≈ 1.01–1.05× RAM speed.

31. What are page replacement algorithms?

When a page fault occurs and no free frame exists, the OS must evict a page.

LRU approximation (hardware reference bit): On access, set reference bit = 1. On replacement, choose page with bit = 0; periodically clear all bits.

32. What is thrashing?

Thrashing occurs when a process spends more time handling page faults than executing:

1. Too many processes loaded → each has too few frames
2. Working sets don't fit in RAM → constant page faults
3. High paging I/O → CPU utilisation drops
4. OS loads more processes (to increase CPU use) → makes it worse

Solutions:

• Working set model: Track active pages per process; only load process if its working set fits
• Page fault frequency: Reduce degree of multiprogramming when fault rate too high
• Increase RAM

33. What is memory-mapped I/O vs port-mapped I/O?

File Systems

34. What is an inode?

An inode (index node) is a data structure in Unix file systems storing file metadata:

Note: Inodes do NOT store the filename — filenames are in directory entries.

35. What is the difference between a hard link and a soft (symbolic) link?

36. What are common file system types?

37. What is journaling in file systems?

Journaling maintains a log (journal) of changes before committing them to the main file system. Prevents corruption on crash:

1. Write changes to journal (fast, sequential)
2. Commit journal entry
3. Apply changes to file system
4. Clear journal entry

On crash recovery, replay incomplete journal entries to restore consistency — much faster than checking entire file system (like fsck).

Journal modes (ext4):

• writeback: Only metadata journaled (fastest, some data risk)
• ordered: Data written before metadata journaled (default; good balance)
• journal: Both data and metadata journaled (safest, slowest)

38. What is RAID?

RAID (Redundant Array of Inexpensive Disks) combines multiple disks for performance or redundancy:

Virtual Memory and I/O

39. What is demand paging?

Demand paging loads pages into RAM only when they are first accessed (on page fault), not all at once at process start.

Page fault handling:

1. CPU references page not in memory → hardware raises page fault trap
2. OS checks if access is valid (check page table, address space)
3. Find a free frame (or evict a page)
4. Load requested page from disk into frame
5. Update page table: set present bit = 1
6. Restart the faulting instruction

40. What is copy-on-write (COW)?

After fork(), instead of copying the entire parent's address space, the child and parent share the same physical pages marked read-only. When either process writes to a page:

1. Page fault triggered
2. OS creates a private copy of that page for the writing process
3. Both processes now have separate copies

Benefit: fork() + exec() is very fast (exec replaces address space immediately; most pages never copied).

41. What is DMA (Direct Memory Access)?

DMA allows I/O devices to transfer data directly to/from RAM without CPU intervention:

1. CPU programs DMA controller with source, destination, size
2. CPU returns to other work
3. DMA controller transfers data between device and memory
4. DMA raises interrupt when complete
5. CPU processes interrupt, checks results

Without DMA: CPU must copy each byte → wastes CPU cycles on I/O.

42. What is an interrupt? How does interrupt handling work?

An interrupt is a signal to the CPU that an event requires immediate attention.

Types:

• Hardware interrupts: Keyboard press, NIC packet received, disk I/O complete
• Software interrupts (traps): System calls, exceptions (division by zero, page fault)

Handling:

1. CPU finishes current instruction
2. Saves current context (PC, registers, flags)
3. Looks up handler in Interrupt Descriptor Table (IDT)
4. Jumps to interrupt service routine (ISR) in kernel mode
5. ISR handles the event
6. Restores context, resumes interrupted process

Kernel Types and Boot

43. What are kernel types?

Trade-off: Monolithic = faster (no context switch between services). Microkernel = more secure/reliable (service crash doesn't crash kernel).

44. What happens during the OS boot process?

1. Power on → CPU starts in real mode, jumps to firmware (BIOS/UEFI)
2. POST (Power-On Self Test) — hardware check
3. Boot device — firmware finds bootable device (MBR/GPT)
4. Bootloader (GRUB, Windows Boot Manager) — loads kernel from disk
5. Kernel initialisation — sets up memory, interrupts, scheduler
6. Init process — kernel launches PID 1 (systemd/init) in user space
7. Services start — systemd starts daemons, mounts filesystems
8. Login prompt — display manager or TTY login

45. What is the difference between 32-bit and 64-bit addressing?

Advanced Topics

46. What is process scheduling in multi-core systems?

Challenges unique to multi-core:

Affinity scheduling: Prefer to reschedule process on the core that last ran it. Improves cache hit rate.

47. What are the different types of kernels threads vs user threads?

Modern systems use M:N mapping (many user threads → pool of kernel threads) for the best of both worlds.

48. What is virtual memory segfault vs stack overflow?

The OS sends SIGSEGV (signal 11) to the process, which typically terminates it with a core dump.

49. What is the difference between swapping and paging?

Modern OSes use paging + swap (page-level swapping) — individual pages are swapped, not whole processes.

50. What is the producer-consumer problem? How do you solve it?

Classic synchronization problem: Producers add items to a shared buffer; consumers remove them. Buffer has finite size.

Requirements:

• Producers wait when buffer is full
• Consumers wait when buffer is empty
• No race conditions on buffer access

Solution using semaphores:

semaphore mutex = 1;     // mutual exclusion for buffer
semaphore empty = N;     // count of empty slots (initially N)
semaphore full  = 0;     // count of full slots (initially 0)

// Producer
wait(empty);     // wait for empty slot
wait(mutex);     // lock buffer
add_item(buffer);
signal(mutex);   // unlock
signal(full);    // notify consumer

// Consumer
wait(full);      // wait for item
wait(mutex);     // lock buffer
remove_item(buffer);
signal(mutex);   // unlock
signal(empty);   // notify producer

Order matters: Always wait the counting semaphore before the mutex to avoid deadlock.

Common mistakes

OS vs related fields

FAQ

Q: What's the difference between a process and a thread?
A: A process is an independent program with its own memory space. Threads are lightweight execution units within a process that share the same memory. Multiple threads can run in parallel (multi-core) or concurrently (time-sharing) within one process.

Q: How does the OS prevent one process from reading another's memory?
A: Each process has its own page table. The CPU's Memory Management Unit (MMU) translates virtual addresses through the current process's page table. Any access outside the mapped virtual address space triggers a segfault. The kernel page table is mapped into every process but protected (not accessible from user mode).

Q: What's the difference between a page fault and a segfault?
A: A page fault is a normal OS event — a valid page isn't currently in RAM, so the OS loads it from disk and execution continues. A segfault (SIGSEGV) is a fatal access to an address the process has no right to access — the OS sends a signal that usually terminates the process.

Q: What happens on a context switch?
A: The OS saves the current process's registers, program counter, and flags into its PCB, then loads the next process's PCB into the CPU registers. If switching to a different process (not just different thread), the TLB is also flushed (or ASID-tagged entries invalidated).

Q: How does virtual memory enable isolation and security?
A: Each process sees its own virtual address space (commonly 0–2⁴⁸ bytes on x86-64). The kernel controls the page tables — it maps each process's pages to different physical frames. Process A's virtual address 0x1000 and Process B's virtual address 0x1000 point to completely different physical RAM locations.

Q: What is the difference between a semaphore and a mutex in practice?
A: A mutex should be unlocked by the same thread that locked it — it provides ownership semantics and is used for mutual exclusion. A semaphore is a signaling mechanism without ownership — it's ideal for producer-consumer (producer signals, consumer waits). Using a semaphore as a mutex is possible but signals/waits can come from any thread, which can lead to subtle bugs.