OS Interview Questions

Process: • Independent program in execution with own memory space • Has own address space, code, data, heap, stack • Communication via IPC (pipes, sockets, shared memory) • Context switching is expensive • One process crash doesn't affect others

Thread: • Lightweight unit of execution within a process • Shares memory with other threads of same process • Communication via shared memory (direct) • Context switching is cheap • One thread crash can crash entire process

Key Point: Threads share heap but have separate stacks.

1. FCFS (First Come First Serve) • Non-preemptive, simple, causes convoy effect

2. SJF (Shortest Job First) • Non-preemptive, optimal average waiting time • Can cause starvation

3. SRTF (Shortest Remaining Time First) • Preemptive SJF, even better waiting time

4. Round Robin • Preemptive, time quantum based • Good for time-sharing systems • No starvation

5. Priority Scheduling • Based on priority, can cause starvation • Solution: Aging

Best for interviews: Know Round Robin, Priority, and their trade-offs.

All 4 conditions must hold simultaneously:

1. Mutual Exclusion • At least one resource must be non-sharable • Only one process can use at a time

2. Hold and Wait • Process holding resources can request more

3. No Preemption • Resources can't be forcibly taken

4. Circular Wait • P1 → P2 → P3 → P1 (circular chain)

How to Prevent: • Break Mutual Exclusion: Use sharable resources • Break Hold & Wait: Request all at once • Break No Preemption: Allow resource preemption • Break Circular Wait: Order resources, request in order

Virtual Memory: Technique that allows execution of processes larger than physical memory.

How it works:

1. Uses disk as extension of RAM
2. Only needed pages loaded (demand paging)
3. Gives each process illusion of large contiguous memory

Key Components: • Page Table: Maps virtual to physical addresses • TLB: Cache for page table entries • Swap Space: Disk area for swapped pages

Page Fault:

1. Access page not in memory
2. Trap to OS
3. Find page on disk
4. Load into free frame (or replace one)
5. Update page table
6. Restart instruction

Benefits: • Run programs larger than RAM • Better memory utilization • Process isolation

Paging: • Divides memory into fixed-size pages/frames • Eliminates external fragmentation • May have internal fragmentation • Invisible to programmer • 1D address (page + offset)

Segmentation: • Divides memory into variable-size segments • Based on logical divisions (code, data, stack) • Has external fragmentation • Visible to programmer • 2D address (segment + offset)

Comparison:

Modern OS: Use both (segmented paging)

Thrashing: System spends more time paging than executing useful work.

Cause: • Too many processes • Each gets fewer frames than needed • Constant page faults • CPU utilization drops • OS adds more processes (makes it worse!)

Signs: • High page fault rate • Low CPU utilization • High disk I/O

Prevention:

1. Working Set Model • Give each process enough frames for its working set

2. Page Fault Frequency • Monitor fault rate • Add frames if too high • Remove if too low

3. Reduce multiprogramming • Suspend some processes

4. Local replacement • Process only replaces its own pages

Semaphore: Integer variable for process synchronization.

Operations: • wait(S) / P(S): Decrement, block if < 0 • signal(S) / V(S): Increment, wake waiting process

Types:

1. Binary Semaphore (Mutex) • Value: 0 or 1 • Used for mutual exclusion

2. Counting Semaphore • Value: 0 to N • Used for resource counting

Example - Producer Consumer:

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)

Context Switch: Saving state of current process and loading state of another process.

When does it happen? • Time slice expires (preemption) • Process makes blocking system call • Higher priority process arrives • Interrupt occurs

What is saved (PCB): • Program counter • CPU registers • Memory management info • I/O status • Scheduling info

Time Taken: • Typically 1-1000 microseconds • Pure overhead (no useful work)

Why Thread Switch is Faster: • Threads share address space • No need to switch memory mappings • Only save/restore registers

Optimization: • Minimize context switches • Use user-level threads • Efficient scheduling algorithms

When all frames are full, which page to replace?

1. FIFO (First In First Out) • Replace oldest page • Simple but has Belady's Anomaly

2. Optimal (OPT) • Replace page not used for longest future time • Best but impractical (needs future knowledge)

3. LRU (Least Recently Used) • Replace page not used for longest past time • Good approximation of OPT • Implementation: Counter or Stack

4. Clock (Second Chance) • Circular queue with reference bit • If R=0: replace, If R=1: clear R, move on

Performance: OPT > LRU > Clock ≈ FIFO

Important: LRU is most commonly asked!

Race Condition: When outcome depends on the order of execution of concurrent processes accessing shared data.

Example:

counter = 5
P1: counter++ (read 5, increment, write 6)
P2: counter-- (read 5, decrement, write 4)

If interleaved:
P1 reads 5
P2 reads 5
P1 writes 6
P2 writes 4  ← Wrong! Should be 5

Solutions:

1. Mutex/Locks • Only one process in critical section

2. Semaphores • More flexible than mutex

3. Monitors • High-level synchronization

4. Atomic Operations • Hardware support for atomicity

Key: Always protect shared resources with synchronization primitives!

Mutex (Mutual Exclusion): • Binary (0 or 1) • Owned by the locking thread • Only owner can unlock • Used for mutual exclusion

Semaphore: • Can be any non-negative integer • Not owned by any thread • Any thread can signal • Used for signaling and resource counting

Key Differences:

When to use: • Mutex: Protecting critical section • Semaphore: Producer-consumer, resource pool

User Mode: • Limited privileges • Can't directly access hardware • Can't execute privileged instructions • Application code runs here • If crash, only that process affected

Kernel Mode: • Full privileges • Direct hardware access • Can execute any instruction • OS kernel runs here • If crash, system crash

Mode Switch (Trap):

User Mode
    │
    │ System Call / Interrupt
    ▼
Kernel Mode
    │
    │ Return
    ▼
User Mode

Why Two Modes? • Protection: Prevent user programs from:

• Accessing other processes' memory
• Directly manipulating hardware
• Executing dangerous instructions

• Stability: Faulty user program can't crash OS

System Call: Interface between user programs and OS kernel.

Process:

1. User program invokes system call
2. Mode switch: User → Kernel
3. OS executes requested service
4. Mode switch: Kernel → User
5. Return result to program

Categories & Examples: • Process Control: fork(), exec(), exit(), wait() • File Management: open(), read(), write(), close() • Device Management: ioctl(), read(), write() • Information: getpid(), alarm(), sleep() • Communication: pipe(), shmget(), mmap()

Example - Reading a file:

fd = open("file.txt", O_RDONLY);  // System call
read(fd, buffer, 100);             // System call
close(fd);                         // System call

Belady's Anomaly: Counter-intuitive situation where increasing page frames causes MORE page faults.

Occurs with: FIFO page replacement

Example: Reference String: 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5

3 frames: 9 page faults 4 frames: 10 page faults (MORE!)

Why FIFO causes this: • FIFO doesn't consider page usage frequency • Oldest page might still be needed • More frames can evict useful pages

Algorithms that DON'T have this: • LRU (Least Recently Used) • Optimal (OPT) • Stack-based algorithms

Interview Tip: Know this is specific to FIFO!

Non-Preemptive: • Process runs until it terminates or blocks • CPU cannot be taken away forcefully • Simple to implement • Can cause starvation • Examples: FCFS, SJF

Preemptive: • CPU can be taken from running process • Based on priority or time quantum • Better response time • More context switches (overhead) • Examples: Round Robin, SRTF, Priority

Comparison:

File System: Method to store, organize, and retrieve data on storage devices.

Key Components: • Files: Named collection of related data • Directories: Container for files and other directories • Metadata: Info about files (size, permissions, timestamps)

File Allocation Methods:

1. Contiguous Allocation • Files stored in consecutive blocks • Fast sequential access • External fragmentation problem

2. Linked Allocation • Each block points to next • No external fragmentation • Slow random access

3. Indexed Allocation (Most Common) • Index block contains pointers to all file blocks • Support for random access • Example: Unix inode

inode Structure (Unix):

• File type, permissions
• Owner, group
• Size, timestamps
• Direct pointers (12)
• Single indirect pointer
• Double indirect pointer
• Triple indirect pointer

Disk Scheduling: Deciding order to service disk I/O requests.

Key Term: • Seek Time: Time to move disk arm to track

Algorithms:

1. FCFS (First Come First Serve) • Simple, fair • Can cause zig-zag arm movement

2. SSTF (Shortest Seek Time First) • Choose nearest request • Better than FCFS • Can cause starvation

3. SCAN (Elevator Algorithm) • Move in one direction, service all • Reverse at end • More uniform wait time

4. C-SCAN (Circular SCAN) • Like SCAN but jumps to start • More uniform response time

5. LOOK / C-LOOK • Like SCAN/C-SCAN but reverses at last request • Doesn't go to end of disk

Comparison:

fork(): System call to create a new process (child) that is a copy of the calling process (parent).

What happens:

1. New PCB created for child
2. Child gets copy of parent's address space
3. Child gets copies of parent's file descriptors
4. Both processes continue from the next instruction

Return Values: • Parent: Gets child's PID (positive) • Child: Gets 0 • Error: Returns -1

#include <unistd.h>
#include <stdio.h>

int main() {
    int pid = fork();
    
    if (pid == 0) {
        // Child process
        printf("I am child, my PID: %d\n", getpid());
    } else if (pid > 0) {
        // Parent process
        printf("I am parent, child PID: %d\n", pid);
    } else {
        // Error
        printf("Fork failed!\n");
    }
    
    return 0;
}

Copy-on-Write (COW): • Initially parent and child share pages • Only copy when either writes • Optimization to avoid copying everything

Zombie Process: • Child has terminated but parent hasn't called wait() • Takes up entry in process table • Also called "defunct" process • Can't be killed (already dead!)

How it happens:

Child finishes → sends SIGCHLD to parent
Parent doesn't call wait() → child becomes zombie

Fix: • Parent calls wait() or waitpid() • If parent dies, init (PID 1) adopts and cleans

Orphan Process: • Child is running but parent has terminated • Adopted by init process (PID 1) • Not a problem - just re-parented

Comparison:

Prevention: • Always call wait() for child processes • Use signal handler for SIGCHLD • Double fork technique

Starvation: • Process waits indefinitely for resources • Resources ARE available, just not given • Other processes keep getting priority • Process is technically runnable

Causes: • Priority scheduling without aging • Unfair resource allocation • Continuous stream of high-priority processes

Deadlock: • Processes wait forever in circular dependency • Resources NOT available (held by waiting processes) • Involves 2+ processes • No progress possible for anyone

Key Differences:

Solutions:

Starvation: • Aging: Increase priority over time • Fair scheduling (Round Robin)

Deadlock: • Prevention (break one condition) • Avoidance (Banker's algorithm) • Detection & Recovery