Operating Systems

Build a strong foundation by understanding what an OS is, its core functions, and the different types used across modern computing environments.

• Definition: software that manages hardware resources and provides services to applications

• Functions: process management, memory management, file management, I/O management, security

• Types: batch, time-sharing, real-time, distributed, embedded, network operating systems

• Batch OS: groups similar jobs, executes without user interaction, used in payroll systems

• Time-sharing OS: multiple users share CPU time through rapid switching, interactive computing

• Real-Time OS (RTOS): guarantees response within strict time constraints, used in embedded systems

• Kernel role: core component managing resources, hardware abstraction, system calls

• Multiprogramming vs multitasking: multiple programs in memory vs CPU switching between tasks

Understand the structural design of an OS — how the kernel works, how modes of operation protect the system, and how user programs interact with hardware.

• Kernel: core of OS, manages CPU, memory, devices, provides system call interface

• User space vs kernel space: applications run in user space, kernel operates in protected kernel space

• System calls: interface between user programs and kernel services

• System call examples: open(), read(), write(), fork(), exec(), wait()

• User mode: restricted access, cannot execute privileged instructions or access hardware directly

• Kernel mode: unrestricted access to hardware, can execute privileged instructions

• Mode transition: system calls, interrupts, exceptions cause switch from user to kernel mode

• Monolithic kernel vs microkernel: entire OS in kernel space (Linux) vs minimal kernel with services in user space (Minix)

Learn how the OS creates, manages, and switches between processes — the fundamental unit of execution in every operating system.

• Process definition: program in execution with its own address space, resources, and state

• Process states: New, Ready, Running, Waiting/Blocked, Terminated

• State transitions: Ready to Running (dispatch), Running to Ready (interrupt), Running to Waiting (I/O request)

• Process Control Block (PCB): stores process state, program counter, registers, memory limits, open files

• Context switching: saving state of current process and loading state of next process

• Context switching overhead: time spent saving/loading state instead of executing processes

• Process creation: allocating memory, initializing PCB, loading program, setting initial state

• Parent-child relationship: parent creates child using fork(), child inherits parent's attributes

Master how threads enable concurrent execution within a process and understand the differences between user-level and kernel-level thread models.

• Thread definition: lightweight process, unit of execution within a process

• Multithreading: multiple threads in single process sharing code, data, and resources

• User-level threads (ULT): managed by thread library in user space, kernel unaware

• Kernel-level threads (KLT): managed by kernel, enables true parallelism on multicore systems

• ULT limitation: blocking system call blocks entire process, cannot utilize multiple CPUs

• Many-to-one model: many user threads to one kernel thread, limited parallelism

• One-to-one model: each user thread mapped to kernel thread, overhead of kernel thread creation

• Many-to-many model: multiplexes many user threads onto smaller or equal number of kernel threads

Understand how the OS decides which process runs on the CPU — a heavily tested interview topic covering algorithms, trade-offs, and real-world scenarios.

• CPU scheduling: determines which process runs on CPU when multiple processes are ready

• FCFS (First-Come, First-Served): processes executed in arrival order, simple but prone to convoy effect

• SJF (Shortest Job First): process with shortest CPU burst executes first, optimal average waiting time

• Preemptive SJF (SRTF): if new process has shorter remaining time, preempts current process

• Priority scheduling problem: starvation — low-priority processes may never execute

• Round Robin (RR): each process gets small time quantum, circular queue, ideal for time-sharing

• Multilevel Queue (MLQ): separate queues for different process types, each with own scheduling algorithm

• Choosing scheduling algorithm: consider CPU utilization, throughput, turnaround time, waiting time, response time

Deeply understand deadlock — its four necessary conditions, and how to prevent, avoid, detect, and recover from it in real systems.

• Deadlock: set of processes waiting indefinitely for resources held by other processes in the set

• Coffman's four conditions: mutual exclusion, hold and wait, no preemption, circular wait

• Deadlock prevention: eliminate one of the four necessary conditions

• Deadlock avoidance: dynamically examines resource allocation state using Banker's algorithm

• Safe state: system can allocate resources to each process in some order avoiding deadlock

• Resource Allocation Graph (RAG): cycle in RAG indicates potential deadlock

• Deadlock recovery: process termination (abort all or one at a time) or resource preemption

• Deadlock vs starvation: deadlock is permanent blocking, starvation is indefinite postponement but process may eventually execute

Understand how the OS manages physical and virtual memory — including paging, segmentation, page replacement algorithms, and the concept of virtual memory.

• Paging: divides physical memory into fixed-size frames, logical memory into pages — eliminates external fragmentation

• Segmentation: divides program into logical segments (code, data, stack) with variable sizes

• Virtual memory: allows execution of processes not completely in physical memory, illusion of large memory

• Page table: maps logical page numbers to physical frame numbers

• Page fault: occurs when requested page not in physical memory, must be loaded from disk

• FIFO page replacement: replaces oldest page in memory

• LRU (Least Recently Used): replaces page that hasn't been used for longest time

• Thrashing: excessive paging where system spends more time paging than executing — prevented by working set model

Learn how operating systems organize and manage data on storage devices — including allocation strategies, directory structures, and real-world file systems.

• File system purpose: organizes and stores files on storage devices, provides access methods

• Contiguous allocation drawback: external fragmentation, difficult to grow files

• Linked allocation: file blocks linked together via pointers in each block

• Indexed allocation: separate index block contains pointers to all file blocks, supports direct access

• Directory structures: single-level, two-level, tree-structured, acyclic graph allows file sharing

• FAT (File Allocation Table): table maps clusters to files, used in FAT12/16/32

• NTFS features: security (ACLs), encryption, compression, journaling, large file support

• Journaling: logs changes before committing, enables recovery after crashes

Master the tools and techniques used to coordinate concurrent processes — a critical topic for both OS interviews and real-world multithreaded programming.

• Critical section problem: ensuring only one process executes critical code section at a time

• Requirements: mutual exclusion, progress (no deadlock), bounded waiting (no starvation)

• Peterson's solution: uses two shared variables (flag and turn) for two-process mutual exclusion

• Semaphores: synchronization primitive with wait (P) and signal (V) operations

• Types of semaphores: binary (mutex, 0 or 1) and counting (multiple resources)

• Semaphore problems: incorrect usage leads to deadlock and priority inversion

• Monitors: high-level synchronization construct with mutex and condition variables

• Monitors vs semaphores: monitors provide automatic mutex, easier to use correctly

Understand how operating systems protect resources and enforce security — from access control models to malware defense and authentication mechanisms.

• Authentication: verifying identity of user (who are you?)

• Authorization: determining what authenticated user can access (what can you do?)

• Access control models: DAC (Discretionary), MAC (Mandatory), RBAC (Role-Based)

• RBAC advantage: permissions assigned to roles, users assigned to roles, simplifies management

• Malware types: virus (self-replicating), worm (network spreading), trojan (disguised), ransomware

• Password security: complexity requirements, salting, hashing, regular rotation

• Two-Factor Authentication (2FA): combines something you know (password) and something you have (token/phone)

• Principle of Least Privilege: users/processes granted minimum permissions needed