Operating Systems Fundamentals Flashcards

Vocabulary practice flashcards covering core operating systems topics including architecture, process and thread models, CPU scheduling, memory management, file systems, I/O devices, concurrency, and virtualization.

Operating System

The software layer that lies between applications and hardware, providing applications a simpler interface with hardware and managing system resources.

Kernel

The core part of the operating system that executes critical operations with a high level of privilege in supervisor mode and directly interacts with hardware.

Supervisor Mode

A hardware-enforced protection domain with the highest privilege level, allowing code to execute the complete CPU instruction set, interact directly with devices, and access any memory area.

User Mode

A restricted protection domain with the lowest privilege level where applications cannot execute privileged system instructions or directly access restricted memory areas.

System Call

A function call that transitions execution from user mode to supervisor mode, providing a controlled interface for user applications to request privileged operating system services.

Monolithic Kernel

An operating system architecture where a large set of core services (such as process management, memory management, file systems, and device drivers) all execute inside kernel space in supervisor mode.

Microkernel

An operating system architecture that minimizes kernel space to essential features (address-space management, basic scheduling, and basic IPC) while moving other services into user space servers.

Unikernel

A single-application operating system architecture where all software, including application code and system libraries, executes embedded together in supervisor mode.

Process

An abstraction representing an instance of a running program, containing its execution code, memory sections, CPU registers, and open system resources.

Process Control Block (PCB)

A kernel data structure maintained for each process that stores its execution state, PID, CPU register values, memory mappings, and open file descriptors.

Thread

An execution entity within a process that contains its own program counter, register set, and stack, while sharing memory and process resources with other threads in the same process.

Preemption

The ability of an operating system scheduler to forcibly interrupt or suspend a currently running thread to allocate CPU time to another thread.

First-Come First-Served (FCFS)

A non-preemptive scheduling policy that assigns CPU execution time to threads strictly in order of their arrival in the ready queue.

Shortest Job First (SJF)

A non-preemptive scheduling algorithm that sorts ready tasks by total known execution time and runs the task with the shortest total runtime first.

Shortest Remaining Time (SRT)

A preemptive variant of Shortest Job First scheduling that orders threads by remaining runtime and preempts the running thread if a newly arrived thread has a shorter remaining duration.

Round-Robin (RR)

A preemptive scheduling policy where each thread is assigned a fixed time quantum to execute before being preempted and placed at the back of the ready queue.

Address Space

An abstract view of memory as seen by a process, independent from other processes' address spaces and mapped to physical memory by the operating system.

Swapping

A memory management technique that moves whole memory regions or processes between physical RAM and secondary storage devices.

Memory Fragmentation

A phenomenon where available free memory becomes split into multiple small non-contiguous blocks, preventing allocation of contiguous space even when total free memory is sufficient.

Page

A fixed-size contiguous unit of virtual memory addresses mapped into physical memory.

Page Frame

A fixed-size unit of physical memory into which a virtual memory page is mapped.

Memory Management Unit (MMU)

A hardware component situated between the CPU and memory bus that transparently translates virtual addresses into physical addresses using page tables.

Translation Lookaside Buffer (TLB)

A small associative hardware cache located within the MMU that stores recent translations from virtual page numbers to physical page frame numbers.

Copy-on-Write

An optimization technique where parent and child processes share physical page frames after a process duplication until one process attempts a write operation, triggering a page copy.

Segmentation

A virtual memory mechanism that divides process memory into multiple variable-length independent virtual address spaces called segments, each defined by a base address and length limit.

Buddy Allocator

A physical memory page frame allocation algorithm that repeatedly splits physical memory chunks in half down to requested power-of-two block sizes.

File Descriptor

An integer handle managed by the kernel that represents an open file for a process, storing access modes, cursor position, and pointers to the file's underlying inode.

Hard Link

A directory entry that links directly to an existing file inode, incrementing the inode's link counter.

Symbolic Link

A special file type that contains a text path string pointing to another file or directory location rather than linking directly to an inode.

Master Boot Record (MBR)

A legacy disk partitioning structure located in Sector 0 containing bootstrap execution code, a 4-entry partition table, and a boot signature.

GUID Partition Table (GPT)

A modern disk partitioning structure starting at Sector 1 that uses an EFI System Partition (ESP) for bootloaders and maintains a backup table at the end of the drive.

Index Node (Inode)

A file system structure that stores a file's attributes and direct or indirect block pointers to its storage locations on disk.

Buffer Cache

A kernel subsystem that transparently caches disk storage blocks in main memory to optimize file access speeds and reduce disk read/write latency.

Direct Memory Access (DMA)

A hardware mechanism where a specialized controller handles data transfers directly between I/O device hardware and main memory independently of the CPU.

Interrupt

A high-priority hardware or software signal sent to the CPU that suspends current execution to run a dedicated Interrupt Service Routine (ISR).

Interrupt Vector

An array or lookup table in memory containing the entry addresses of interrupt service routines indexed by IRQ line numbers.

Mutex

A synchronization lock object providing mutual exclusion for a critical section through lock and unlock primitives, owned by at most one thread at a time.

Semaphore

A synchronization primitive built around an atomic resource counter that coordinates access using wait and signal operations.

Deadlock

A state where a set of concurrent processes are permanently blocked because each process holds a resource while waiting for another resource held by another process in a circular chain.

Hypervisor

A software layer that creates and manages virtual machines, enabling multiple guest operating systems to execute concurrently on physical hardware.

Container

A lightweight user-space virtualization environment that isolates execution contexts while sharing the host operating system kernel.