Operating Systems

Operating System (OS)

Software that manages computer hardware, software resources, and provides services to applications.

Kernel

The core part of the OS that directly interacts with hardware and manages system resources.

System Call

A programmatic way for user applications to request services from the kernel.

Shell

The interface (command-line or GUI) that allows users to interact with the OS.

Process

A running instance of a program with its own memory, resources, and execution context.

Thread

The smallest unit of CPU execution within a process; shares resources with other threads in the same process.

Context Switch

The act of saving a process/thread’s state and loading another’s so the CPU can switch tasks.

Interrupt

A signal to the CPU indicating an event that needs immediate attention.

Trap

A software-generated interrupt, often triggered by an error or a system call.

Bootloader

Small program that loads the operating system into memory when a computer starts.

Scheduling

The method by which the OS decides which process/thread gets CPU time.

Preemptive Scheduling

Scheduling where the OS can interrupt a process to give CPU time to another.

Non-preemptive Scheduling

Scheduling where a process runs until completion or it voluntarily yields.

Round Robin Scheduling

CPU scheduling algorithm giving each process equal time slices in order.

Priority Scheduling

Scheduling based on process priority values.

Multilevel Queue Scheduling

Divides processes into multiple queues, each with different scheduling policies.

Multilevel Feedback Queue

Dynamic scheduling where processes can move between queues based on behavior.

Process Control Block (PCB)

Data structure used by OS to store information about a process (state, registers, etc.).

Process States

Possible states of a process: New, Ready, Running, Waiting, Terminated.

Zombie Process

A process that has completed execution but still has an entry in the process table.

User-Level Threads

Threads managed in user space, invisible to the kernel.

Kernel-Level Threads

Threads managed directly by the OS kernel.

Multithreading

Running multiple threads within the same process concurrently.

Concurrency

Multiple tasks making progress by interleaving execution.

Parallelism

Multiple tasks executing at the exact same time on different cores.

Race Condition

Incorrect behavior that occurs when multiple threads access shared data without synchronization.

Critical Section

Code segment that must not be executed by more than one thread at a time.

Mutex (Mutual Exclusion)

A lock used to prevent multiple threads from accessing a resource at the same time.

Semaphore

Synchronization primitive that controls access to resources by multiple processes/threads.

Monitor

High-level synchronization construct combining mutual exclusion and condition variables.

Deadlock

A situation where processes wait indefinitely for resources held by each other.

Four Coffman Conditions

The necessary conditions for deadlock: Mutual exclusion, Hold and wait, No preemption, Circular wait.

Deadlock Prevention

Strategy that ensures at least one Coffman condition never holds.

Deadlock Avoidance

Strategy where the OS carefully allocates resources to avoid unsafe states.

Banker’s Algorithm

Deadlock avoidance algorithm simulating resource allocation to ensure safety.

Deadlock Detection

Method of checking system state to identify deadlocked processes.

Deadlock Recovery

Terminating or preempting processes/resources to break a deadlock.

Starvation

When a process waits indefinitely due to unfair scheduling.

Livelock

Processes keep changing state in response to each other but make no progress.

Safe State

A system state where at least one sequence of resource allocations avoids deadlock.

Memory Management Unit (MMU)

Hardware that translates virtual addresses to physical addresses.

Paging

Memory management scheme dividing memory into fixed-size pages and frames.

Page Table

Data structure mapping virtual pages to physical frames.

Segmentation

Memory divided into variable-sized segments based on program structure.

Virtual Memory

Illusion of a large, continuous memory space, backed by physical RAM and disk.

Swapping

Moving processes in and out of RAM to disk to manage memory.

Page Fault

An exception when a program accesses a page not currently in RAM.

TLB (Translation Lookaside Buffer)

Cache that speeds up virtual-to-physical address translation.

Demand Paging

Loading pages into memory only when they are needed.

Thrashing

Excessive paging activity that drastically reduces performance.

File System

OS mechanism for storing and organizing data on disks.

File Descriptor

Integer handle used by the OS to access an open file.

Inode

Data structure storing metadata about a file (permissions, size, location).

Directory

A special file that contains references to other files.

Mounting

Attaching a file system to the directory tree.

Journaling File System

File system that logs changes before committing them, ensuring crash recovery.

Block

Smallest unit of storage allocation in a file system.

FAT (File Allocation Table)

File system architecture using a table to map file blocks.

NTFS

File system used by Windows with journaling and metadata support.

EXT4

Popular Linux file system with journaling and large file support.

7. I/O and Devices

Device Driver

Software that allows the OS to interact with hardware devices.

Buffering

Temporarily storing data to smooth out speed mismatches between devices.

Spooling

Queuing data for slow devices like printers.

Polling

Checking device status repeatedly to see if it’s ready.

Interrupt-Driven I/O

Device notifies CPU when it’s ready, reducing busy-waiting.

DMA (Direct Memory Access)

Hardware feature allowing devices to transfer data directly to memory without CPU involvement.

Block Device

Hardware device that stores data in fixed-size blocks (e.g., hard disk).

Character Device

Hardware device that transmits data as a stream (e.g., keyboard).

RAID

Redundant array of independent disks; storage method for redundancy and speed.

SSD vs HDD

SSD uses flash memory (faster, no moving parts), HDD uses spinning disks.

Access Control

Mechanism for defining who can access which resources.

Authentication

Verifying the identity of a user or process.

Authorization

Determining what an authenticated user is allowed to do.

Encryption

Transforming data into an unreadable format to protect it.

Privilege Levels (Rings)

Hardware-enforced levels of execution privilege (e.g., kernel mode vs user mode).

Sandboxing

Isolating applications to limit their access to system resources.

Rootkit

Malicious software that hides its presence by modifying the OS kernel.

Buffer Overflow

Exploit where extra input overwrites memory, often leading to code execution.

SELinux

Linux security module enforcing mandatory access controls.

Trusted Computing Base (TCB)

The set of hardware, software, and controls critical to system security.

Virtualization

Technique of running multiple OS instances on the same physical hardware.

Hypervisor

Software/hardware that manages virtual machines (Type 1 = bare metal, Type 2 = hosted).

Containerization

Lightweight OS-level virtualization (e.g., Docker).

Microkernel

Minimal OS kernel handling only core tasks (IPC, scheduling); rest in user space.

Monolithic Kernel

OS kernel where most services run in kernel mode for speed.

Hybrid Kernel

Combination of monolithic and microkernel designs (e.g., Windows NT).

Exokernel

Minimal OS that gives applications direct control over hardware.

Distributed OS

OS that manages resources across multiple networked computers.

Real-Time OS (RTOS)

OS designed to guarantee deterministic timing for critical applications.

Cloud OS

Operating environment designed for cloud computing platforms.

Throughput

Number of processes completed per unit of time.

Latency

Time taken to complete a single task or request.

Turnaround Time

Total time taken for a process from submission to completion.

Response Time

Time between a request and the first response.

Utilization

Percentage of a system resource being effectively used.

Checkpointing

Saving process state so it can be resumed after failure.

Fault Tolerance

Ability of a system to continue operating despite failures.

Load Balancing

Distributing work evenly across processors or servers.