Introduction to Operating Systems Study Guide

Front

Operating System

Back

System software that manages computer hardware, provides services for application programs, and acts as an intermediary between users and hardware. It controls resource allocation, process execution, and provides abstractions such as files, processes, and devices. The OS enables applications to run without needing to manage hardware directly.

Front

Kernel

Back

The core component of an operating system that runs in privileged mode and directly manages hardware resources like CPU, memory, and I/O. It implements low-level services such as process scheduling, memory management, and device control. User programs and system utilities interact with the kernel via system calls.

Front

System Programs

Back

Software that provides a convenient environment for program development and execution but is not part of the kernel. Examples include compilers, shells, file utilities, and system libraries. They offer higher-level services and interfaces built on top of kernel functionality.

Front

Application Program

Back

End-user software that performs specific tasks like word processing, web browsing, or data analysis. Applications rely on OS-provided abstractions and services (files, processes, networking) rather than direct hardware access. They run in user mode with restricted privileges for protection.

Front

Computer System Organization

Back

The arrangement and interconnection of CPU(s), memory, device controllers, and buses that form a computer. It defines how hardware components communicate, how interrupts are delivered, and how device controllers interface with the OS. Understanding this organization is essential for OS design and optimization.

Front

CPU

Back

The central processing unit that executes instructions and performs computation for programs. It operates in different modes (user and kernel) and responds to interrupts to handle asynchronous events. Modern systems may have multiple CPUs or cores to increase throughput.

Front

Device Controller

Back

Hardware that manages a specific I/O device and handles low-level device operations like data transfer and error detection. The device controller communicates with the CPU via the system bus and signals the OS using interrupts. Device drivers in the OS provide the software interface to the controller.

Front

Device Driver

Back

Kernel-level software that translates generic OS I/O requests into device-specific operations for a controller. Drivers handle initialization, control commands, data transfer, and interrupt handling for their device. They hide hardware details and provide a consistent interface to the OS and applications.

Front

Interrupt

Back

An asynchronous signal from hardware or software that causes the CPU to suspend the current execution and run an interrupt service routine. Interrupts enable timely handling of events like I/O completion, timers, and errors without busy-waiting. They are fundamental for efficient device management and responsiveness.

Front

Interrupt Service Routine

Back

A small kernel routine executed in response to an interrupt to handle the event and initiate any required actions. ISRs perform minimal work (acknowledge device, queue data) and often defer heavy processing to later kernel threads. Proper ISR design is crucial for system responsiveness and correctness.

Front

Main Memory (RAM)

Back

Volatile storage used to hold currently executing programs and their data for fast access by the CPU. The OS manages allocation and protection of memory regions for processes, and uses techniques like virtual memory to provide each process with an isolated address space. Data in RAM is lost when power is removed.

Front

Secondary Storage

Back

Nonvolatile storage such as HDDs and SSDs used for persistent data and long-term program storage. The OS manages file systems, block allocation, and data transfer between secondary storage and main memory. Secondary storage is slower but retains data across reboots and power loss.

Front

Direct Memory Access (DMA)

Back

A mechanism that allows device controllers to transfer data directly between devices and main memory without continuous CPU involvement. DMA improves performance by offloading bulk data movement and reducing CPU interrupts. The OS coordinates DMA setup and ensures memory protection during transfers.

Front

Single-Processor System

Back

A computer system with a single CPU that executes one instruction stream at a time. The OS multiplexes CPU time among multiple processes using scheduling to give the illusion of concurrency. Resource management and protection are still essential but simpler than in multiprocessor systems.

Front

Multiprocessor / SMP

Back

A system with multiple CPUs (or cores) that share memory and I/O resources, often configured as symmetric multiprocessing (SMP) where all CPUs run the same OS. Multiprocessor systems increase throughput and parallelism but require synchronization, cache coherence, and scalable OS data structures. The OS schedules work across processors to maximize utilization.

Front

Clustered System

Back

A group of independent computers connected via a high-speed network that cooperate to provide higher availability, scalability, or performance. Clusters can run coordinated distributed applications or provide redundancy for services. The OS and middleware handle communication, job scheduling, and fault tolerance across nodes.

Front

Resource Management

Back

OS responsibilities for allocating CPU time, memory, storage, and I/O devices among competing processes. The OS implements policies and mechanisms (scheduling, memory allocation, file systems) to ensure efficient, fair, and safe resource usage. Effective resource management maximizes throughput while meeting performance and isolation goals.

Front

Multiprogramming / Multitasking

Back

Techniques that allow multiple programs or tasks to reside in memory and share CPU time by switching execution among them. Multiprogramming increases CPU utilization by running other jobs when one waits for I/O, while multitasking focuses on interactive responsiveness by frequent context switches. Scheduling policies determine which process runs next.

Front

Security and Protection

Back

Mechanisms to control access to system resources and ensure only authorized processes or users can perform sensitive operations. Protection uses hardware features (privileged modes, memory protection) and OS policies (access control lists, authentication) to enforce isolation. Security extends to defending against malicious attacks and ensuring system integrity.

Front

Virtualization

Back

Abstraction of physical hardware to create multiple isolated execution environments (virtual machines) on the same host. Virtualization enables running different OSs simultaneously, improves resource utilization, and provides isolation and portability. The hypervisor or virtual machine monitor manages virtual hardware and mediates access to real devices.

Front

Distributed Systems

Back

Collections of independent computers that appear to users as a single coherent system and share resources over a network. Distributed systems improve scalability, fault tolerance, and resource sharing, and can be implemented as network operating systems or tightly integrated distributed OSs. They require protocols for communication, synchronization, and consistency.

Front

Kernel Data Structures

Back

Data structures used by the OS kernel to manage processes, memory, files, and devices, including lists, stacks, queues, trees, hash tables, and bitmaps. These structures enable efficient lookup, allocation, scheduling, and tracking of resources. Choosing the right structures is key for scalable and performant OS behavior.

Front

Computing Environments

Back

Different contexts where operating systems operate, such as traditional desktops, mobile devices, client-server, peer-to-peer, cloud platforms, and real-time embedded systems. Each environment imposes unique requirements on the OS (power, latency, scalability, availability). OS design adapts to meet these constraints and usage models.

Front

Real-time Systems

Back

Systems that must produce correct results within strict timing constraints, where missing deadlines can cause failures or hazards. They are used in scientific experiments, medical imaging, industrial control, and automotive systems. Real-time OSs provide predictable scheduling, low-latency interrupt handling, and timing guarantees.

Front

Free Software

Back

Software that grants users freedoms to run, study, modify, and redistribute the program, typically associated with licensing models championed by the Free Software Foundation. Free refers to liberty rather than price and emphasizes user control over software. Examples and movements around free software stress ethical and practical aspects of software freedom.

Front

Open-Source Software

Back

Software whose source code is made available under licenses that permit users to study, modify, and distribute the code, often with collaborative development practices. Open-source focuses on practical benefits like transparency, reliability, and community-driven improvement, and may have diverse licensing terms. GNU/Linux is a primary example of a widely used open-source OS.

Front

GNU/Linux

Back

A family of operating systems combining the GNU project's tools and utilities with the Linux kernel, usually distributed in various distributions like Red Hat and Ubuntu. GNU/Linux is open-source, allows studying and modifying source code, and supports broad hardware and application ecosystems. It is widely used in servers, desktops, embedded systems, and education.

Front

Richard Stallman / GNU Project

Back

Richard Stallman is the founder of the Free Software Movement and initiator of the GNU project to create a free Unix-like operating system. The GNU project developed many key tools and philosophies that, combined with the Linux kernel, produced GNU/Linux. Stallman's advocacy centers on software freedom and copyleft licensing to preserve user rights.

Front

BSD UNIX

Back

A family of UNIX-derived operating systems originating from the Berkeley Software Distribution, which has a complex history of code sharing and licensing. BSD variants (FreeBSD, OpenBSD, NetBSD) have influenced many systems and contributed networking and file system innovations. Licensing differences led to both proprietary and open-source forks over time.

Front

Solaris

Back

A UNIX operating system originally developed by Sun Microsystems with roots in BSD and System V, known for enterprise features and scalability. Solaris has undergone shifts between open-source and proprietary models, with some components being open-sourced at times. It has influenced enterprise OS design and filesystem development.

Front

Open-Source Education Benefits

Back

Open-source operating systems provide accessible source code and tooling for students and researchers to study, modify, and experiment with real-world OS implementations. This hands-on access accelerates learning about internals, enables projects and contributions, and fosters collaboration and innovation. It also increases transparency and reproducibility in OS education.

Front

Inter-process Communication (IPC)

Back

Mechanisms that allow processes to exchange data and synchronize their actions, implemented via message passing, shared memory, pipes, sockets, and RPCs. IPC is essential for modularity, concurrency, and distributed computing, and the OS provides primitives to ensure correctness and protection. Different IPC methods trade off performance, complexity, and synchronization semantics.

Front

Message Passing

Back

An IPC model where processes exchange discrete messages using send and receive operations, often with blocking or nonblocking semantics. Message passing simplifies synchronization and works well across distributed systems because it encapsulates data movement and ordering. Implementations vary in buffering, ordering guarantees, and addressing mechanisms.

Front

Shared Memory

Back

An IPC mechanism where multiple processes map the same memory region into their address spaces to read and write data directly. Shared memory is fast because it avoids copying, but requires explicit synchronization (semaphores, mutexes) to avoid race conditions. POSIX shared memory uses memory-mapped objects and functions like shm_open and mmap to set up shared regions.

Front

Producer-Consumer Problem

Back

A classic synchronization problem where producers generate data and place it into a buffer while consumers remove and process data, requiring coordination to avoid overflow or underflow. Solutions use blocking send/receive, semaphores, or condition variables and vary depending on buffer capacity (zero, bounded, unbounded). It illustrates IPC patterns and synchronization primitives.

Front

Buffering Types

Back

Three buffering models for message passing: zero-capacity (no queueing; sender blocks until receiver accepts), bounded-capacity (finite queue; sender blocks if full), and unbounded-capacity (infinite queue; sender never blocks). The choice affects latency, throughput, and complexity of flow control. Real systems commonly use bounded buffers with flow-control policies.

Front

POSIX Shared Memory

Back

A standardized API for creating named shared memory objects using system calls like shm_open, ftruncate, and mmap to map shared regions into processes. POSIX shared memory enables fast data exchange between cooperating processes on the same host, with synchronization handled by separate primitives. It is widely supported on Unix-like systems.

Front

Mach Message Passing

Back

An IPC facility from the Mach microkernel that uses ports as communication endpoints and supports message headers and bodies with various types. Mach allows multiple senders and single receivers per port and offers mechanisms for queuing, blocking, and varied message sizes. The mach_msg primitive handles sending and receiving while the system enforces port-based security and routing.

Front

Windows ALPC

Back

Advanced Local Procedure Call (ALPC) is a Windows IPC mechanism for efficient communication between processes on the same machine, providing connection and communication ports. ALPC supports small-message copying and large-message shared-memory or direct transfers, optimizing for varied payload sizes and performance. It is used extensively within Windows for system services and client-server interactions.

Front

Pipes

Back

A simple IPC primitive that provides unidirectional byte-stream communication between related processes, typically parent and child. Named pipes (FIFOs) extend pipes to allow unrelated processes to communicate using a persistent name in the filesystem. Pipes are easy to use for stream-oriented data transfer but require synchronization for structured messages.

Front

Sockets

Back

Communication endpoints used for networked IPC that are identified by IP addresses and port numbers, enabling bidirectional communication between processes across machines. Sockets support various protocols (TCP, UDP) and are the foundation of client-server architectures on networks. The OS provides APIs to create, bind, listen, connect, send, and receive over sockets.

Front

Remote Procedure Call (RPC)

Back

An abstraction that lets a program invoke a procedure on a remote machine as if it were local, with the RPC system handling network communication. RPC requires marshaling parameters and return values into messages, transporting them across the network, and unmarshaling on the receiver side. It simplifies distributed programming but must handle latency, partial failures, and differing data representations.

Front

Marshaling and Unmarshaling

Back

Processes of converting procedure parameters, return values, and data structures into a contiguous format for transmission (marshaling) and reconstructing them at the receiver (unmarshaling). These operations handle differences in data representation (endianness, alignment) and are essential for correct RPC and networked IPC. Efficient marshaling minimizes copying and overhead.

Front

Ports

Back

Named communication endpoints used by some IPC systems (e.g., Mach ports, network ports for sockets) to identify destinations for messages or connections. Ports provide addressing, access control, and routing semantics for message delivery. They help structure IPC topologies and enforce security boundaries between communicating entities.

Front

Blocking Send/Receive

Back

A communication mode where a sender or receiver waits (blocks) until the matching operation completes (delivery or availability of data). Blocking simplifies synchronization and flow control but can reduce concurrency if not managed carefully. Nonblocking variants allow polling or asynchronous notifications to avoid stalls.