Systems Programming & OS Internals

Operating system processes, memory, and hardware

System Call

function that requests a service from the operating system kernel (e.g., read(), write() )

User Mode

restricted mode where normal programs run (limited hardware access)

Kernel Mode

privileged mode with full hardware access; OS code runs here

Interrupt

hardware or software signal that temporarily halts CPU execution to handle an event

Trap/Exception

software-generated interrupt (e.g., divide-by-zero)

Context Switch

OS operation that saves on process’s state and loads another’s

Process

running instance of a program with its own memory space and resources

Thread

lightweight process sharing memory and resources with other threads of the same process

Scheduler

OS component that decides which process/thread runs next on CPU

Kernel

core component of OS managing processes, memory, devices, and system calls

System Library (libc)

provides user-space wrappers for system calls and utilities

Virtual Memory

abstraction where each process sees a continuous memory space mapped to physical memory via page tables

Physical Memory

actual RAM in hardware

Paging

dividing virtual memory into fixed-size blocks mapped to frames in physical memory

Page Table

structure mapping virtual addresses to physical ones

MMU (Memory Management Unit)

hardware that handles virtual-to-physical address translation

Segmentation

older memory model dividing memory into segments (code, data, stack)

Heap

memory for dynamically allocated data (malloc/free in C)

Stack (Memory)

area for function calls and local variables; automatically managed by CPU

Buffer/Buffer Overflow

continuous memory region; overflow occurs when data exceeds buffer capacity and overwrites adjacent memory

Race Condition

when program behavior depends on timing/order of concurrent operations

Critical Section

code segment where shared resources are accessed; must not be executed by multiple threads simultaneously

Mutex (Mutual Exclusion Lock)

synchronization primitive allowing only one thread at a time in a critical section

Semaphore

counter-based synchronization for controlling access to a limited number of resources

Deadlock

situation where threads wait indefinitely for each other to release resources

Context Switching

saving/restoring CPU registers and state when switching between threads/processes

Atomic Operation

an operation that cannot be interrupted (appears indivisible)