Top 50 Operating System Interview Questions

• Process - independent program in execution. Has its own memory space, file handles, and resources. Heavyweight.
• Thread - lightweight unit of execution within a process. Shares memory and resources with other threads in the same process.
• Context switch between processes is more expensive than between threads.

A context switch is the OS saving the state (PCB) of the current process/thread and loading the state of the next one. Overhead includes saving/restoring registers, program counter, and memory maps. Frequent context switches reduce CPU efficiency.

• FCFS (First Come First Served) - non-preemptive. Simple. Convoy effect.
• SJF (Shortest Job First) - optimal average waiting time. Can cause starvation.
• Round Robin - preemptive. Each process gets a time quantum. Fair. Good for time-sharing.
• Priority Scheduling - highest priority runs first. Can cause starvation; solved by aging.
• MLFQ (Multi-Level Feedback Queue) - combines multiple queues with different priorities.

• Mutual Exclusion - at least one resource is non-shareable.
• Hold and Wait - a process holds resources while waiting for more.
• No Preemption - resources cannot be forcibly taken from a process.
• Circular Wait - a circular chain of processes each waiting for a resource held by the next.
• All four must hold simultaneously for a deadlock to occur.

• Prevention - eliminate one of the four necessary conditions. Simple but restrictive.
• Avoidance - use algorithms like Banker's Algorithm to ensure system never enters unsafe state.
• Detection - allow deadlocks to occur, detect them, and recover by killing processes or preempting resources.

• Paging - divides memory into fixed-size pages. No external fragmentation. Internal fragmentation possible.
• Segmentation - divides memory into variable-size segments (code, data, stack). No internal fragmentation. External fragmentation possible.
• Modern OS use segmentation with paging combined.

Virtual memory allows processes to use more memory than physically available by storing parts of the address space on disk (swap space). The OS uses demand paging to load pages only when needed. Provides memory isolation between processes.

A page fault occurs when a process accesses a page not currently in physical memory. The OS must load the page from disk (swap space) into a free frame. Types: minor (page in memory but not mapped) and major (page must be read from disk).

Thrashing occurs when a process spends more time swapping pages in and out than executing. Caused by insufficient physical memory. Solution: reduce degree of multiprogramming, use working set model, or add more RAM.

• FIFO - replaces the oldest page. Simple. Suffers from Belady's anomaly.
• LRU (Least Recently Used) - replaces the page not used for the longest time. Good performance. Expensive to implement exactly.
• Optimal - replaces the page not used for the longest time in the future. Theoretical best. Not implementable.
• Clock (Second Chance) - approximates LRU using a reference bit. Practical.

• Internal fragmentation - wasted space inside an allocated block (e.g., paging allocates 4KB but process needs 3KB).
• External fragmentation - free memory exists but is scattered in small non-contiguous blocks (e.g., segmentation).
• Compaction can reduce external fragmentation but is expensive.

A semaphore is a synchronization primitive with an integer value. Operations: wait (P) decrements value; if negative, blocks. signal (V) increments value; wakes a blocked process. Binary semaphore (0/1) acts like a mutex. Counting semaphore allows N concurrent accesses.

// Semaphore usage (pseudocode)
semaphore mutex = 1;
wait(mutex);   // P operation - enter critical section
// critical section
signal(mutex); // V operation - exit critical section

• Mutex - ownership-based lock. Only the thread that locked it can unlock it. Used for mutual exclusion.
• Semaphore - signaling mechanism. Any thread can signal. Can be used for both mutual exclusion and synchronization.
• Binary semaphore is similar to mutex but lacks ownership semantics.

• Critical section - code segment accessing shared resources. Must not be executed by more than one process simultaneously.
• Requirements: Mutual Exclusion, Progress (if no process in CS, one waiting should enter), Bounded Waiting (limit on how long a process waits).
• Solutions: Peterson's algorithm, semaphores, monitors, hardware instructions (test-and-set).

The producer-consumer (bounded buffer) problem: producers add items to a shared buffer, consumers remove them. Requires synchronization to prevent overflow, underflow, and race conditions. Solved with semaphores: empty, full, and mutex.

// Pseudocode
semaphore empty = N, full = 0, mutex = 1;
// Producer
wait(empty); wait(mutex);
add_item();
signal(mutex); signal(full);
// Consumer
wait(full); wait(mutex);
remove_item();
signal(mutex); signal(empty);

• Non-preemptive - once a process gets CPU, it runs until it voluntarily yields or terminates. Simple. Can cause starvation.
• Preemptive - OS can interrupt a running process and give CPU to another. Better responsiveness. More complex. Used in modern OS.

A system call is the interface between a user program and the OS kernel. Allows user-mode programs to request kernel services (file I/O, process creation, memory allocation). Examples: read(), write(), fork(), exec(), open(), close().

• User mode - restricted mode. Cannot directly access hardware or kernel memory. Most application code runs here.
• Kernel mode - privileged mode. Full access to hardware and memory. OS kernel runs here.
• Mode switch occurs on system calls, interrupts, and exceptions.

A file system organizes and stores files on storage devices. Manages file metadata (name, size, permissions, timestamps), directory structure, and free space. Examples: ext4 (Linux), NTFS (Windows), APFS (macOS), FAT32.

An inode (index node) is a data structure in Unix file systems storing file metadata: permissions, owner, size, timestamps, and pointers to data blocks. Does NOT store the filename. Directory entries map filenames to inode numbers.

• Hard link - another directory entry pointing to the same inode. File data persists until all hard links are deleted. Cannot span file systems.
• Soft link (symbolic link) - a file containing a path to another file. Can span file systems. Breaks if target is deleted.

ln file.txt hardlink.txt      # hard link
ln -s file.txt softlink.txt   # soft link (symlink)

Spooling (Simultaneous Peripheral Operations On-Line) stores data in a buffer (spool) for a device that cannot accept interleaved data streams. Classic example: print spooler queues print jobs so multiple processes can send print requests without waiting.

• Multiprogramming - multiple programs loaded in memory. CPU switches when one does I/O. Maximizes CPU utilization.
• Multitasking - multiple tasks share CPU via time-slicing. Gives illusion of parallelism on single CPU.
• Multiprocessing - multiple CPUs execute processes truly in parallel.

Belady's anomaly is the counterintuitive phenomenon where increasing the number of page frames causes more page faults with FIFO page replacement. Does not occur with LRU or Optimal algorithms. LRU and Optimal are stack algorithms, immune to Belady's anomaly.

• Monolithic kernel - entire OS runs in kernel space. Fast (no context switches for services). Hard to maintain. Examples: Linux, Unix.
• Microkernel - minimal kernel; services (file system, drivers) run in user space. More stable and secure. Slower due to IPC overhead. Examples: Mach, QNX.

• Program - passive entity. A file on disk containing instructions.
• Process - active entity. A program in execution with its own memory, registers, and state.
• One program can create multiple processes (e.g., running the same executable twice).

• fork() - creates a new child process as a copy of the parent. Both parent and child continue from the fork() call.
• exec() - replaces the current process image with a new program. Does not create a new process.
• Typical pattern: fork() then exec() in child to run a new program.

pid_t pid = fork();
if (pid == 0) {
    // child process
    execl("/bin/ls", "ls", "-l", NULL);
} else {
    // parent process
    wait(NULL);
}

• Zombie process - process has finished but its entry remains in the process table because the parent has not called wait(). Wastes process table entries.
• Orphan process - parent has terminated before the child. The child is adopted by init (PID 1) which calls wait() for it.

• Binary semaphore - value is 0 or 1. Any thread can signal it. No ownership.
• Mutex - has ownership. Only the thread that locked it can unlock it. Prevents priority inversion with priority inheritance.
• Use mutex for mutual exclusion; binary semaphore for signaling.

• Semaphore - low-level primitive. Programmer must carefully place wait/signal calls. Error-prone.
• Monitor - high-level synchronization construct. Mutual exclusion is automatic. Uses condition variables (wait, signal). Easier to use correctly.

• Demand paging - pages loaded only when accessed (on page fault). Less memory used initially. More page faults at startup.
• Pre-paging - loads pages before they are needed (predicted). Fewer page faults. May waste memory loading unneeded pages.

• Hard real-time - deadlines must be met absolutely. Missing a deadline is a system failure. Examples: aircraft control, pacemakers.
• Soft real-time - deadlines are important but occasional misses are tolerable. Examples: video streaming, online gaming.
• RTOS provides deterministic scheduling (e.g., Rate Monotonic, EDF).

• Cooperative - processes voluntarily yield CPU. If a process does not yield, it can monopolize CPU. Used in early Windows (3.x), macOS (classic).
• Preemptive - OS forcibly interrupts processes after time quantum expires. Fairer. Used in modern OS.

The TLB is a hardware cache that stores recent virtual-to-physical address translations. Speeds up memory access by avoiding page table lookups. TLB hit: O(1) translation. TLB miss: must walk page table. TLB is flushed on context switch.

• PCB (Process Control Block) - data structure storing process state: PID, program counter, registers, memory maps, open files, scheduling info.
• TCB (Thread Control Block) - stores thread-specific state: thread ID, program counter, registers, stack pointer. Shares process resources.

• Logical address (virtual address) - generated by CPU. Used by programs. Starts from 0 for each process.
• Physical address - actual location in RAM. Translated from logical address by MMU using page tables.
• Memory Management Unit (MMU) performs the translation.

• Blocking I/O - process waits until I/O completes. Simple but wastes CPU.
• Non-blocking I/O - process continues execution; checks later or gets notified. More complex but efficient.
• Asynchronous I/O - OS notifies process when I/O completes via callback or signal.

• Kernel thread - managed by OS. OS is aware of each thread. True parallelism on multi-core. Context switch is expensive.
• User thread - managed by user-space library. OS sees only one process. Fast context switch. Cannot run truly in parallel.
• Modern systems use hybrid (M:N) model.

A file descriptor is a non-negative integer that uniquely identifies an open file within a process. Standard descriptors: 0 (stdin), 1 (stdout), 2 (stderr). Created by open(), socket(), pipe(). Closed with close().

• Pipe - unidirectional IPC between related processes (parent-child). Anonymous pipe: temporary. Named pipe (FIFO): persistent, between unrelated processes.
• Socket - bidirectional IPC. Can communicate between processes on different machines over a network. More flexible.

int fd[2];
pipe(fd);  // fd[0] = read end, fd[1] = write end
write(fd[1], "hello", 5);
read(fd[0], buf, 5);

• Spinlock - busy-waits (loops) until lock is available. No context switch. Efficient for very short critical sections on multi-core.
• Mutex - puts thread to sleep if lock unavailable. Context switch overhead. Better for longer critical sections.

A page table maps virtual page numbers to physical frame numbers. Each process has its own page table. Multi-level page tables (2-level, 4-level in x86-64) reduce memory overhead. Inverted page table uses one entry per physical frame.

The working set model tracks the set of pages a process actively uses in a time window (working set window). If a process's working set fits in memory, it runs efficiently. If not, thrashing occurs. Used to determine how many frames to allocate to each process.

Memory-mapped files map a file or device into the process's virtual address space. Allows file I/O using memory operations (read/write to pointers). Used for: shared memory between processes, loading executables, and large file processing.

// mmap example (C)
int fd = open("file.txt", O_RDONLY);
char *data = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
// access data[i] directly
munmap(data, size);

DMA allows hardware devices to transfer data directly to/from memory without CPU involvement. The CPU initiates the transfer, then the DMA controller handles it. CPU is free to do other work. Used for disk I/O, network cards, and audio.

• Interrupt - asynchronous signal from hardware (keyboard, timer, disk). Causes CPU to stop current task and run interrupt handler.
• Trap (software interrupt) - synchronous event caused by program (system call, division by zero, page fault). Transfers control to OS.

A race condition occurs when the outcome of a program depends on the relative timing of events (e.g., two threads reading and writing shared data without synchronization). Result is non-deterministic and can cause data corruption.

// Race condition example
int counter = 0;
// Thread 1: counter++  (read, increment, write)
// Thread 2: counter++  (read, increment, write)
// Final value may be 1 instead of 2 if interleaved

Priority inversion occurs when a high-priority task is blocked waiting for a resource held by a low-priority task, while a medium-priority task preempts the low-priority task. Solution: priority inheritance (low-priority task temporarily inherits high-priority task's priority).

The Banker's Algorithm is a deadlock avoidance algorithm. Before granting a resource request, it checks if the resulting state is safe (all processes can eventually complete). If safe, grant; otherwise, make the process wait. Requires knowing maximum resource needs in advance.

• Hard real-time - missing a deadline causes system failure. Used in safety-critical systems: aircraft autopilot, pacemakers, anti-lock brakes.
• Soft real-time - deadlines are important but occasional misses are acceptable. Used in multimedia, gaming, and video conferencing.
• RTOS schedulers (Rate Monotonic, EDF) guarantee hard real-time deadlines.