Operating Systems Roadmap
A complete beginner-to-advanced Operating Systems roadmap covering fundamentals, processes, scheduling, synchronization, deadlocks, memory, file systems, storage, I/O, protection and security.
Learning outline
Expand a stage, choose a topic and start its Gate Smashers lectures.
01Foundations6 topics · 8 lectures0 / 8
▶What is an Operating System?0 / 1 lectures
▶Types of Operating Systems0 / 3 lectures
▶System Calls & APIs0 / 1 lectures
▶User Mode vs Kernel Mode0 / 1 lectures
▶Boot Process, Linker & Loader0 / 1 lectures
▶Linux & Shell Basics0 / 1 lectures
02Processes & Threads4 topics · 5 lectures0 / 5
▶Process Creation: fork, exec, wait & exit0 / 2 lectures
▶Schedulers & Process Queues0 / 1 lectures
▶Processes vs Threads0 / 1 lectures
▶User-Level vs Kernel-Level Threads0 / 1 lectures
03CPU Scheduling6 topics · 11 lectures0 / 11
▶CPU Scheduling Basics & Metrics0 / 3 lectures
▶First Come First Serve (FCFS)0 / 1 lectures
▶SJF & SRTF Scheduling0 / 3 lectures
▶Priority Scheduling & Aging0 / 1 lectures
▶Round Robin Scheduling0 / 1 lectures
▶Multilevel Queue & MLFQ0 / 2 lectures
04Synchronization & Deadlocks9 topics · 21 lectures0 / 21
▶Race Conditions & Critical Sections0 / 2 lectures
▶Hardware Synchronization Primitives0 / 3 lectures
▶Mutexes & Semaphores0 / 3 lectures
▶Classic Synchronization Problems0 / 5 lectures
▶Deadlocks0 / 1 lectures
▶Coffman Conditions & Resource Allocation Graph0 / 2 lectures
▶Deadlock Prevention0 / 1 lectures
▶Deadlock Avoidance & Banker’s Algorithm0 / 2 lectures
▶Deadlock Detection & Recovery0 / 2 lectures
05Memory Management12 topics · 27 lectures0 / 27
▶Memory Management Basics0 / 2 lectures
▶Contiguous Allocation & Fragmentation0 / 2 lectures
▶First Fit, Next Fit, Best Fit & Worst Fit0 / 3 lectures
▶Swapping & Overlays0 / 1 lectures
▶Paging Fundamentals0 / 5 lectures
▶Page Tables & Page Table Entries0 / 1 lectures
▶Multilevel & Inverted Page Tables0 / 2 lectures
▶Translation Lookaside Buffer (TLB)0 / 3 lectures
▶Segmentation0 / 1 lectures
▶Virtual Memory0 / 1 lectures
▶Page Replacement Algorithms0 / 5 lectures
▶Thrashing & Working Set0 / 1 lectures
06File Systems, I/O & Security9 topics · 20 lectures0 / 20
▶File-System Fundamentals0 / 1 lectures
▶File Attributes, Operations & Access Methods0 / 1 lectures
▶File Allocation Methods0 / 4 lectures
▶UNIX Inodes & File Metadata0 / 1 lectures
▶Hard Disk Architecture0 / 1 lectures
▶Disk Access Time0 / 1 lectures
▶Disk Scheduling Algorithms0 / 7 lectures
▶Protection & Security0 / 1 lectures
▶Operating Systems Roadmap Complete0 / 3 lectures
Topics covered in this roadmap
Use this stage-by-stage outline to understand the complete learning path before opening the interactive roadmap.
Foundations
What is an Operating System?
An operating system is system software that manages hardware resources and provides services to programs. It sits between applications and hardware so the computer can be used safely, efficiently and conveniently.
OS Services & Core Functions
An OS provides a standard set of services that make hardware usable by applications and users. These services cover program execution, resource management, storage, communication, protection and error handling.
Types of Operating Systems
Operating systems can be classified by how they schedule work, support users, use processors and meet timing constraints. Each type is designed around different goals such as throughput, interactivity, scalability or predictability.
Kernel Architecture
Kernel architecture describes how operating-system services are organized and how much functionality runs in privileged mode. Common designs include monolithic kernels, layered systems, microkernels, modular kernels and hybrid approaches.
System Calls & APIs
System calls are controlled entry points through which user programs request services from the kernel. APIs such as POSIX or language libraries often wrap these calls, so an API call and a system call are related but not always identical.
User Mode vs Kernel Mode
Modern CPUs support privilege levels so normal applications cannot directly perform sensitive operations. User mode is restricted, while kernel mode can execute privileged instructions and access protected hardware and memory.
Interrupts, Exceptions & Traps
Interrupts and exceptions let the CPU react to events that require operating-system attention. Hardware interrupts are usually asynchronous, while exceptions and traps are caused by events related to the currently executing instruction.
Boot Process, Linker & Loader
A computer reaches a usable OS through firmware, boot loading, kernel initialization and user-space startup. Linkers and loaders prepare programs for execution by resolving symbols, relocating addresses and placing executable code into memory.
Linux & Shell Basics
Linux is a widely used Unix-like operating system whose command-line tools expose many core OS concepts directly. Basic shell commands help students work with files, processes, permissions, directories and system information.
Processes & Threads
Program vs Process
A program is a passive set of instructions stored on a device, while a process is an active instance of a program in execution. A process has an execution state, address space, resources and operating-system metadata.
Process Creation: fork, exec, wait & exit
Operating systems provide mechanisms for creating a new process, replacing its program image and waiting for it to finish. In Unix-like systems, fork, exec, wait and exit form the classic process-creation lifecycle.
Process States & State Transitions
A process moves through states that represent whether it is being created, waiting for CPU time, executing or waiting for an event. The standard five-state model is New, Ready, Running, Waiting or Blocked, and Terminated.
Schedulers & Process Queues
Schedulers decide when processes enter the system, which ready process receives the CPU and when suspended processes return to memory. Long-term, short-term and medium-term scheduling operate at different frequencies and control different parts of the process lifecycle.
Process Control Block (PCB)
A Process Control Block is the kernel data structure that stores the information required to manage and resume a process. The OS updates the PCB as the process changes state, consumes CPU time or acquires resources.
Context Switching
A context switch occurs when the CPU stops running one process or thread and begins running another. The OS saves the outgoing execution state and restores the state of the selected incoming task.
Processes vs Threads
A thread is a schedulable execution unit inside a process, while a process is an isolated resource container with its own address space. Threads in the same process share code, data and open resources but maintain separate execution state.
User-Level vs Kernel-Level Threads
Threads may be managed entirely in user space, directly by the kernel or through a mapping between user and kernel threads. The chosen model affects scheduling, blocking behavior, parallelism and thread-management overhead.
Concurrency vs Parallelism
Concurrency means multiple tasks make progress during overlapping periods, while parallelism means multiple tasks execute at the same physical time. An OS can provide concurrency on a single CPU through scheduling and parallelism on multicore hardware.
Inter-Process Communication (IPC)
IPC mechanisms allow isolated processes to exchange data and coordinate their activities. Shared memory and message passing are the two broad models, implemented through mechanisms such as pipes, message queues, signals and sockets.
CPU Scheduling
CPU Scheduling Basics & Metrics
CPU scheduling decides which process in the ready queue receives the CPU and for how long. Scheduling algorithms are compared using utilization, throughput, turnaround time, waiting time, response time and fairness.
First Come First Serve (FCFS)
FCFS schedules ready processes in order of arrival and does not preempt a running process. It is simple and fair by arrival order, but long jobs can delay many short jobs.
SJF & SRTF Scheduling
Shortest Job First selects the ready process with the smallest predicted CPU burst, while Shortest Remaining Time First is its preemptive form. These algorithms can minimize average waiting time when future burst lengths are known or estimated accurately.
Priority Scheduling & Aging
Priority scheduling selects the ready process with the highest scheduling priority and can be preemptive or non-preemptive. Because low-priority tasks may wait indefinitely, aging is often used to gradually improve the priority of long-waiting processes.
Round Robin Scheduling
Round Robin gives each ready process a fixed time quantum and cycles through the ready queue. It is designed for fairness and interactive response, but the choice of quantum strongly affects overhead and responsiveness.
Multilevel Queue & MLFQ
Multilevel Queue scheduling separates processes into fixed queues, while Multilevel Feedback Queue scheduling allows processes to move between queues. These designs let the OS apply different priorities and algorithms to interactive, batch and CPU-bound workloads.
Real-Time Scheduling Basics
Real-time scheduling focuses on meeting timing constraints rather than only maximizing average throughput. Hard real-time systems treat missed deadlines as failures, while soft real-time systems tolerate occasional deadline misses with reduced quality.
Synchronization & Deadlocks
Race Conditions & Critical Sections
A race condition occurs when concurrent execution accesses shared state and the final result depends on timing or interleaving. The critical-section problem asks how to protect shared data while still allowing safe progress and bounded waiting.
Hardware Synchronization Primitives
Hardware provides atomic instructions that operating systems and libraries use to build locks and synchronization primitives. Operations such as test-and-set and compare-and-swap can change shared state without interruption from competing processors.
Mutexes & Semaphores
Mutexes and semaphores are common synchronization primitives used to control access to shared resources and coordinate events. A mutex represents ownership of a critical section, while a semaphore maintains a counter changed through atomic wait and signal operations.
Monitors & Condition Variables
A monitor is a high-level synchronization construct that encapsulates shared state together with the operations allowed on that state. Condition variables inside a monitor allow threads to sleep until a required condition becomes true.
Classic Synchronization Problems
Classic synchronization problems capture recurring coordination patterns found in real systems. Producer-consumer, readers-writers, printer-spooler and dining-philosophers examples illustrate mutual exclusion, resource counting, ordering, starvation and deadlock.
Deadlocks
A deadlock is a state in which a set of processes cannot make progress because each is waiting for a resource or event that another process in the set must release. Without intervention, the waiting cycle does not resolve on its own.
Coffman Conditions & Resource Allocation Graph
Four Coffman conditions must hold simultaneously for resource deadlock to be possible: mutual exclusion, hold and wait, no preemption and circular wait. Resource Allocation Graphs visualize requests and assignments between processes and resources.
Deadlock Prevention
Deadlock prevention designs resource-allocation rules so that at least one Coffman condition can never hold. It provides a structural guarantee against deadlock, but the restrictions may lower utilization or reduce concurrency.
Deadlock Avoidance & Banker’s Algorithm
Deadlock avoidance permits flexible allocation but grants a request only when the system can remain in a safe state. Banker’s algorithm uses declared maximum demands to test whether a safe completion sequence still exists.
Deadlock Detection & Recovery
Deadlock detection allows allocations to proceed and periodically checks whether a deadlock has formed. Once detected, recovery can terminate processes, preempt resources or roll work back when the system supports checkpointing.
Memory Management
Memory Management Basics
Memory management controls how processes are placed in RAM and how their addresses are translated and protected. It combines allocation, relocation, sharing, protection and movement between primary and secondary storage.
Contiguous Allocation & Fragmentation
Contiguous memory allocation places each process in one continuous physical region. Fixed and variable partitioning are simple to understand but can waste memory through internal or external fragmentation.
First Fit, Next Fit, Best Fit & Worst Fit
Placement algorithms choose which free hole should satisfy a variable-size memory request. Different policies trade search cost, fragmentation patterns and the sizes of holes that remain after allocation.
Swapping & Overlays
Swapping moves an entire process or large memory image between RAM and secondary storage to free physical memory, while overlays manually load only the program part needed at a given time. These techniques predate modern virtual memory but explain how systems cope with limited RAM.
Paging Fundamentals
Paging divides virtual memory into fixed-size pages and physical memory into equal-size frames. A page table maps virtual page numbers to physical frame numbers so a process can occupy non-contiguous locations in RAM.
Page Tables & Page Table Entries
A page table stores the mapping and control information needed to translate virtual pages into physical frames. Each page-table entry usually combines a frame number with status and protection bits used by the MMU and OS.
Multilevel & Inverted Page Tables
Large address spaces often use page-table structures that avoid allocating one enormous flat table. Multilevel paging allocates table portions on demand, while an inverted page table stores entries indexed mainly by physical frames.
Translation Lookaside Buffer (TLB)
A TLB is a small associative cache that stores recently used virtual-to-physical address translations. By avoiding a page-table walk on a hit, it greatly reduces the average cost of virtual-memory translation.
Segmentation
Segmentation divides a program into variable-size logical units such as code, data, stack or modules. Each logical address contains a segment number and offset, and a segment table stores the base, limit and protection information for each segment.
Virtual Memory
Virtual memory gives each process a large, protected address space that does not need to be fully resident in RAM. The OS and MMU keep active portions in physical memory and obtain missing portions from secondary storage when required.
Demand Paging & Page Fault Handling
Demand paging loads a virtual page into RAM only when the process actually references it. A page fault transfers control to the OS, which validates the access, obtains a frame, loads the page and restarts the interrupted instruction.
Page Replacement Algorithms
Page replacement chooses which resident page to evict when a page fault occurs and no free frame is available. FIFO, Optimal, LRU and related algorithms use different information and therefore produce different fault patterns.
Thrashing & Working Set
Thrashing occurs when processes have too few frames for their active working sets, causing the system to spend more time paging than executing useful work. Working-set and page-fault-frequency ideas help the OS estimate how much memory a process needs to run efficiently.
File Systems, I/O & Security
File-System Fundamentals
A file system organizes persistent data into named files and directories and defines how that data is stored, found and protected. It combines logical naming with metadata, allocation structures, caching and storage-device operations.
File Attributes, Operations & Access Methods
Files expose metadata and a standard set of operations so programs can create, open, read, write and manage persistent data. Access methods determine whether a program processes data sequentially, directly by position or through indexed structures.
Directory Structures & Path Names
Directories organize files into namespaces and allow users and programs to locate data by path. Directory designs range from simple flat layouts to hierarchical trees and graph-like structures that support shared links.
File Allocation Methods
File-allocation methods determine how the blocks belonging to a file are placed and located on storage. Contiguous, linked and indexed allocation trade access speed, growth flexibility, fragmentation and metadata overhead.
Free-Space Management
A file system must track storage blocks that are not currently allocated so they can be reused efficiently. Common approaches include bitmaps, free lists, grouping and counting contiguous free regions.
UNIX Inodes & File Metadata
An inode is a Unix-style file-system metadata structure that represents a file independently of its directory name. It stores attributes and pointers or references used to locate the file data blocks on storage.
Hard Disk Architecture
Traditional magnetic disks store data on rotating platters organized into tracks and sectors and access it using movable read/write heads. Understanding this physical layout explains why request order and head movement matter for disk performance.
Disk Access Time
Disk access time for a magnetic disk is mainly the time to move the head, wait for the desired sector to rotate under it and transfer the data. Queueing and controller delays can add additional latency.
Disk Scheduling Algorithms
Disk scheduling orders pending magnetic-disk requests to reduce head movement, improve throughput and control waiting time. FCFS, SSTF, SCAN, LOOK and their circular variants use different trade-offs between locality and fairness.
I/O System & Device Management
The I/O subsystem provides a uniform way for programs to use hardware devices with very different characteristics. Device drivers, controllers and kernel I/O layers translate generic requests into device-specific commands and completion events.
DMA, Buffering, Caching & Spooling
Operating systems reduce I/O overhead by moving data efficiently and smoothing differences between device and CPU speeds. DMA, buffering, caching and spooling solve different parts of this performance and coordination problem.
Protection & Security
Protection controls how authenticated subjects may use operating-system objects, while security defends the system against unauthorized access and attacks. Together they aim to preserve confidentiality, integrity, availability and controlled sharing.
Access Control: ACLs & Capabilities
Access-control models represent who may perform which operations on protected objects. ACLs attach permissions to objects, while capability systems give subjects unforgeable references that carry authority to specific objects.
Operating Systems Roadmap Complete
Operating systems connect process execution, scheduling, synchronization, memory, storage, I/O and protection into one resource-management system. Mastery comes from understanding not only each mechanism but also the trade-offs and interactions between them.