Operating System Complete Notes + Viva Questions — IT Sem 4

Operating System kya hai?

An Operating System is system software that manages hardware resources and provides services to user programs. It acts as an intermediary between user and hardware.

Functions of OS:

• Process Management
• Memory Management
• File System Management
• I/O Device Management
• Security & Protection
• Networking

Types of OS:

• Batch OS (SPOOLING — Simultaneous Peripheral Operations OnLine)
• Time-Sharing OS (multiple users, context switching)
• Real-Time OS (RTOS) — hard/soft deadlines
• Distributed OS
• Embedded OS

---

1. Process Management

Process vs Program

| Aspect | Program | Process | |---|---|---| | Definition | Static code on disk | Running instance of program | | State | Passive | Active | | Memory | No allocation | Gets PCB, stack, heap | | Existence | Permanent | Temporary |

Process Lifecycle

Process States:

New → Ready → Running → Waiting → Ready → Running → Terminated
        ↑__________________________|
        (I/O complete → back to Ready)

PCB (Process Control Block): OS ka "student record" for each process. Contains: PID, Process state, CPU registers, Program counter, Memory info, I/O info, Scheduling priority

Process vs Thread

| Feature | Process | Thread | |---|---|---| | Memory | Separate address space | Shared within process | | Creation | Slower (fork syscall) | Faster | | Communication | IPC (pipes, sockets) | Shared memory | | Context Switch | Expensive | Cheaper | | Crash effect | Only that process | Can crash whole process |

Multithreading Benefits: Responsive UI, parallel computation, resource sharing, faster context switch.

---

2. CPU Scheduling

Goal: Maximize CPU utilization, throughput. Minimize waiting time, turnaround time, response time.

Scheduling Criteria

Turnaround Time = Completion Time - Arrival Time
Waiting Time    = Turnaround Time - Burst Time
Response Time   = First Response - Arrival Time

Scheduling Algorithms

1. FCFS (First Come First Served):

• Non-preemptive, simple FIFO queue
• Problem: Convoy effect (short job waits behind long job)

2. SJF (Shortest Job First):

• Non-preemptive: Pick process with shortest burst time
• Optimal for minimizing average waiting time
• Problem: Starvation of long processes

3. SRTF (Shortest Remaining Time First):

• Preemptive version of SJF
• Best average waiting time but requires burst time knowledge

4. Round Robin (RR):

Time Quantum (Q) = fixed time slice (e.g., 4ms)
Each process gets Q time, then goes to back of queue
Preemptive — good for time-sharing systems

5. Priority Scheduling:

• Each process has a priority number
• Preemptive/Non-preemptive
• Problem: Starvation → Solution: Aging (priority increases with wait time)

6. Multilevel Queue:

• Different queues for different process types (Foreground, Background)
• Each queue has own scheduling algorithm

Example — RR Calculation:

Processes: P1(burst=10), P2(burst=4), P3(burst=5)  Q=3

Gantt Chart:
| P1(3) | P2(3) | P3(3) | P1(3) | P2(1) | P3(2) | P1(4) |
0       3       6       9       12      13      15      19

WT: P1=9, P2=6, P3=7  Avg WT = 7.33ms

---

3. Process Synchronization

Critical Section Problem

Critical Section: Code where shared resources are accessed. Must ensure:

• Mutual Exclusion: Only one process at a time
• Progress: If CS is empty, a waiting process must enter
• Bounded Waiting: Process can't wait forever

Semaphores

// Binary Semaphore (Mutex) — 0 or 1
// Counting Semaphore — non-negative integer

wait(S):   // P operation — acquire
  while (S <= 0) ; // busy wait
  S--;

signal(S): // V operation — release
  S++;

Producer-Consumer with Semaphore:

empty = n (buffer capacity)
full  = 0
mutex = 1

Producer:           Consumer:
wait(empty)         wait(full)
wait(mutex)         wait(mutex)
  ADD item            REMOVE item
signal(mutex)       signal(mutex)
signal(full)        signal(empty)

Deadlock

4 Necessary Conditions (Coffman Conditions):

1. Mutual Exclusion — Resource non-shareable
2. Hold & Wait — Process holds one resource, waits for another
3. No Preemption — Resource can't be forcibly taken
4. Circular Wait — P1 waits for P2, P2 waits for P1...

Deadlock Handling:

• Prevention: Break any one Coffman condition
• Avoidance: Banker's Algorithm (safe/unsafe state check)
• Detection: Resource Allocation Graph (RAG) cycle detection
• Recovery: Terminate process, preempt resources

Banker's Algorithm:

For each resource request:
1. Tentatively allocate
2. Check if safe state exists (all processes can finish)
3. If safe → grant; if unsafe → deny and wait

---

4. Memory Management

Memory Allocation Strategies

| Strategy | Idea | Problem | |---|---|---| | First Fit | Allocate first hole big enough | External fragmentation | | Best Fit | Smallest hole that fits | Slow, small leftover holes | | Worst Fit | Largest hole | Large leftovers, wastes memory |

Fragmentation:

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

Paging

Memory divided into fixed-size frames (physical) and pages (logical). Page Table maps logical → physical.

Logical Address = Page Number (p) + Page Offset (d)
Physical Address = Frame Number (f) + Offset (d)

Page Table Entry: Frame number + Valid bit + Protection bits

TLB (Translation Lookaside Buffer): Hardware cache for page table
TLB Hit → 1 memory access
TLB Miss → 2 memory accesses (page table + actual data)

Segmentation

Memory divided into variable-size segments (code, data, stack). Each has base + limit registers.

Physical Address = Base[segment] + Offset
Protection: Check offset < Limit

Virtual Memory & Page Replacement

Page Fault: Required page not in RAM → OS loads it from disk.

Page Replacement Algorithms:

| Algorithm | Idea | Optimal? | |---|---|---| | FIFO | Replace oldest page | No — Belady's anomaly | | LRU | Replace least recently used | Near optimal, costly | | Optimal | Replace page not used longest in future | Optimal but not implementable | | LRU Approximation | Clock algorithm, reference bits | Practical |

Thrashing: Too many page faults, CPU spends more time in paging than execution.

• Solution: Working Set Model, reduce degree of multiprogramming

---

5. File System

File: Named collection of related data. Attributes: Name, Type, Size, Permissions, Timestamps.

File Operations: Create, Open, Read, Write, Seek, Close, Delete, Truncate

Directory Structure:

• Single-level, Two-level, Tree-structured (most common), Acyclic Graph, General Graph

File Allocation Methods:

| Method | How | Pros | Cons | |---|---|---|---| | Contiguous | Blocks stored together | Fast sequential access | External fragmentation | | Linked | Each block → pointer to next | No fragmentation | Slow random access | | Indexed | Index block stores all pointers | Fast random access | Overhead for small files |

Disk Scheduling (to minimize seek time):

• FCFS: Requests in order — simple but slow
• SSTF: Nearest request first — better but starvation
• SCAN (Elevator): Move in one direction, then reverse
• C-SCAN: Move in one direction only, wrap around

---

50 Viva Questions (Exam Focus)

Process & Threads:

1. Process aur Program mein kya difference hai?
2. Thread kya hai, benefits kya hain?
3. Context switching kya hai?
4. Zombie process kya hoti hai? (completed but not reaped by parent)
5. Orphan process kya hai? (parent died before child)
6. IPC ke tarike kaun se hain? (Pipes, Message Queues, Shared Memory, Sockets)
7. Fork syscall kya karta hai?
8. PCB mein kya store hota hai?

Scheduling: 9. CPU scheduling ki need kyon hai? 10. Preemptive aur Non-preemptive mein kya fark hai? 11. Round Robin mein time quantum choose kaise karte hain? 12. Starvation aur Aging kya hain? 13. SJF optimal kyon hai? 14. Convoy effect kab hota hai? 15. Real-time scheduling (EDF, RMS) kya hai?

Synchronization: 16. Race condition kya hai? 17. Mutex aur Semaphore mein fark? 18. Monitor kya hai? 19. Dining Philosophers problem solve kaise karte hain? 20. Deadlock aur Livelock mein fark? 21. Banker's algorithm kab use hota hai? 22. Circular wait kaise prevent karte hain?

Memory: 23. Virtual memory ki need kyon hai? 24. Paging aur Segmentation mein fark? 25. TLB kya hai, kyon zaroori hai? 26. Page fault kaise handle hota hai? 27. Belady's anomaly kya hai? 28. Thrashing kaise rokein? 29. Demand paging kya hai? 30. Copy-on-Write kya hai?

File System: 31. FAT, NTFS, ext4 mein kya difference hai? 32. Inode kya hai? 33. Hard link aur Soft link mein fark? 34. Journaling file system kyon zaroori hai? 35. RAID kya hai, RAID-0 vs RAID-1? 36. Mount kya hota hai?

I/O & Misc: 37. Spooling kya hai? 38. Buffering aur Caching mein fark? 39. DMA kya hai aur kyon fast hai? 40. System call kya hai, examples? 41. User mode aur Kernel mode mein kya fark? 42. Interrupt kya hai? 43. Microkernel vs Monolithic kernel? 44. Hypervisor kya hai? 45. Shell kya hai? 46. /proc filesystem kya hai? 47. Swap space kya hai? 48. Memory leak kya hai, kaise detect karte hain? 49. Busy waiting kyon bura hai? 50. Preemption kya hai, kab zaroori hai?