Operating Systems Glossary

Operating Systems Glossary

Key terms and definitions for the Operating Systems course.

A

Abstraction

Abstraction: The process of hiding complex hardware details behind simple, logical interfaces (e.g., treating a hard drive as a “File”).

Arbitration

Arbitration: The process of managing shared resources (CPU, RAM) among multiple competing processes.

B

BIOS (Basic Input/Output System)

BIOS (Basic Input/Output System): Legacy firmware interface for initializing hardware during the boot process.

Bootloader

Bootloader: A small program (like GRUB) loaded by the firmware that loads the Kernel into memory.

Buffer Cache

Buffer Cache: A region of kernel memory used to hold frequently accessed disk blocks to reduce I/O latency.

C

Context Switch

Context Switch: The process of saving the state of a currently running process and restoring the state of another process so the CPU can switch tasks. Expensive.

CPL (Current Privilege Level)

CPL (Current Privilege Level): A 2-bit value in the CPU’s CS register that determines the current privilege level (Ring 0-3).

D

Deadlock

Deadlock: A situation where a set of processes are blocked because each process is holding a resource and waiting for another resource acquired by some other process.

Direct Memory Access (DMA)

Direct Memory Access (DMA): A hardware feature that allows devices to transfer data to/from RAM independently of the CPU.

G

GRUB (GRand Unified Bootloader)

GRUB (GRand Unified Bootloader): The default bootloader for most Linux distributions.

I

Init

Init: The first process started by the kernel (PID 1). It is responsible for starting all other user-space services. Modern Linux uses Systemd.

Interrupt

Interrupt: A hardware signal (e.g., from a keyboard or disk) that tells the CPU to stop what it’s doing and run an interrupt handler.

Interrupt Service Routine (ISR)

Interrupt Service Routine (ISR): A software function in the kernel that is executed in response to a specific interrupt.

Interrupt Vector Table (IVT)

Interrupt Vector Table (IVT): A data structure used by the CPU to map interrupt numbers (IRQ) to the memory addresses of their corresponding ISRs.

K

Kernel

Kernel: The core component of the OS that runs in Ring 0. It has complete control over the system.

Kernel Mode

Kernel Mode: See Ring 0.

M

Memory-Mapped I/O (MMIO)

Memory-Mapped I/O (MMIO): A method where device registers are mapped to physical memory addresses, allowing the CPU to use standard memory instructions to control hardware.

Microkernel

Microkernel: An OS architecture where the kernel is minimal (IPC, Scheduling) and most services (FS, Drivers) run in User Space.

Monolithic Kernel

Monolithic Kernel: An OS architecture where the entire OS (FS, Drivers, IPC) runs in Kernel Space. Linux is Monolithic.

O

Orphan Process

Orphan Process: A process whose parent has terminated. It is adopted by the init process.

P

Parity

Parity: A technique used in RAID 5/6 to store redundant information (calculated via XOR) to allow data recovery in case of disk failure.

PCB (Process Control Block)

PCB (Process Control Block): A data structure in the kernel that stores information about a process (PID, State, Registers, etc.).

Port-Mapped I/O (PMIO)

Port-Mapped I/O (PMIO): A legacy method where the CPU uses a separate address space and special instructions (IN/OUT) to communicate with devices.

Q

Quantum

Quantum: The time slice allocated to a process in Round Robin scheduling.

R

Race Condition

Race Condition: A situation where multiple processes access shared data concurrently and the outcome depends on the order of execution.

RAID (Redundant Array of Independent Disks)

RAID (Redundant Array of Independent Disks): A technology that combines multiple physical disk drive components into one or more logical units for data redundancy and/or performance improvement.

Ring 0

Ring 0: The highest privilege level on x86 CPUs. Kernel code runs here. Can execute any instruction.

Ring 3

Ring 3: The lowest privilege level. User applications run here. Cannot access hardware directly.

S

Spooling

Spooling: The process of placing data in a temporary storage area (buffer) so it can be processed by a device or program at its own speed (e.g., Print Spooling).

Starvation

Starvation: A situation where a process is indefinitely denied necessary resources to process its work.

Striping

Striping: A technique used in RAID 0/5/10 where data is segmented into blocks and written across multiple disks sequentially to improve throughput.

System Call (Syscall)

System Call (Syscall): The programmatic interface (API) that User Space applications use to request services from the Kernel.

Systemd

Systemd: The modern init system used by most Linux distributions to manage services and boot targets.

T

Trap

Trap: A software-generated interrupt (e.g., a System Call or Divide-by-Zero error) that transfers control to the Kernel.

U

UEFI (Unified Extensible Firmware Interface)

UEFI (Unified Extensible Firmware Interface): The modern replacement for BIOS. It supports larger disks and secure boot.

User Mode

User Mode: See Ring 3.

Z

Zero Copy

Zero Copy: A technique that avoids redundant data copies between intermediate buffers (e.g., Kernel to User space) to improve I/O performance.

Zombie Process

Zombie Process: A process that has completed execution (via exit) but still has an entry in the process table. This occurs if the parent process (PID 1) fails to read the child’s exit status.