Linux System Programming Course

Lesson 1 • Introduction to System Calls

Demonstrates how user programs invoke kernel services via system calls using glibc wrappers and raw syscall. Connects C library functions to their underlying kernel operations.

Lesson 2 • Linux Architecture and Kernel Overview

Covers kernel space vs. user space, monolithic kernel design, and hardware abstraction. Establishes the conceptual framework all subsequent programming topics depend on.

Lesson 3 • Compiling, Linking, and Loading

Explains the full toolchain pipeline from source to executable, including static and dynamic linking. Prepares students to diagnose build errors and understand binary structure.

Lesson 4 • C Language Essentials for Systems Work

Reviews pointers, memory layout, structs, and bitwise operations critical to systems code. Bridges general C knowledge to the low-level patterns used throughout the course.

Lesson 1 • Directory and Metadata Operations

Teaches stat(), directory traversal, and link management including hard and symbolic links. Enables programs to inspect and manipulate filesystem structure programmatically.

Lesson 2 • POSIX File Operations

Covers open(), read(), write(), lseek(), and close() with all relevant flags and modes. Teaches correct usage patterns and common pitfalls such as partial reads and writes.

Lesson 3 • Memory-Mapped Files

Demonstrates mmap() for mapping files into process address space for fast I/O and shared data. Connects file I/O to virtual memory concepts introduced in later chapters.

Lesson 4 • File Descriptors and Open Files

Explains the open-file table, file descriptor integers, and kernel data structures behind them. Grounds all subsequent I/O work in a precise model of how the kernel tracks open files.

Lesson 1 • Process Internals and Attributes

Examines PID, PPID, UID, GID, and the process descriptor fields the kernel maintains. Provides the vocabulary and data model needed to control processes programmatically.

Lesson 2 • Waiting for and Reaping Children

Teaches wait(), waitpid(), and waitid() for collecting child exit status and preventing zombies. Ensures students write leak-free multi-process programs.

Lesson 3 • Executing Programs with exec()

Explains the exec family, argument and environment passing, and what is preserved across exec. Enables students to build shells and process launchers that replace process images correctly.

Lesson 4 • Creating Processes with fork()

Covers copy-on-write semantics, return value handling, and resource inheritance after fork(). Builds the foundation for all multi-process programming patterns in the course.

Lesson 1 • Signal Concepts and Standard Signals

Introduces signal numbers, default dispositions, and the kernel delivery mechanism. Establishes the conceptual model required before writing any signal-handling code.

Lesson 2 • Signal Masks and Blocking

Teaches sigprocmask(), sigset_t manipulation, and critical section protection via blocking. Enables students to prevent signal races in multi-step operations.

Lesson 3 • Async-Signal-Safe Programming

Identifies async-signal-safe functions and patterns for writing correct, re-entrant handlers. Prevents the subtle bugs that arise from calling unsafe functions inside handlers.

Lesson 4 • Real-Time Signals and signalfd

Covers POSIX real-time signals, queuing guarantees, and the signalfd() interface for synchronous handling. Extends signal skills to high-reliability and event-driven architectures.

Lesson 1 • POSIX Message Queues

Teaches mq_open(), mq_send(), mq_receive(), and priority-based message delivery. Provides a structured, typed alternative to byte-stream pipes for message-oriented IPC.

Lesson 2 • Comparing and Selecting IPC Mechanisms

Analyses throughput, latency, complexity, and persistence trade-offs across all IPC types. Equips students to make informed architectural decisions in real system designs.

Lesson 3 • POSIX Semaphores

Covers named and unnamed semaphores, sem_wait/sem_post, and mutual exclusion patterns. Provides the synchronisation layer needed to use shared memory safely.

Lesson 4 • Pipes and FIFOs

Covers anonymous pipes, FIFO creation, and the producer-consumer pattern for related and unrelated processes. Introduces unidirectional byte-stream IPC as the simplest coordination primitive.

Lesson 1 • Advanced mmap() Usage

Demonstrates MAP_ANONYMOUS, MAP_FIXED, huge pages, and madvise() for performance tuning. Extends mmap() skills from file I/O to general-purpose memory management.

Lesson 2 • Heap Allocation and the Allocator

Covers malloc(), calloc(), realloc(), free(), and the glibc allocator internals including arenas. Teaches correct allocation patterns and how to avoid heap corruption.

Lesson 3 • Memory Protection and Permissions

Teaches mprotect() for changing page permissions and guard pages for buffer overflow detection. Enables students to implement security-hardening techniques at the memory level.

Lesson 4 • Virtual Memory Architecture

Explains page tables, virtual address space layout, and the /proc/pid/maps interface. Provides the mental model needed to understand allocator behaviour and mmap() semantics.

Lesson 1 • Thread Creation and Lifecycle

Covers pthread_create(), thread attributes, detach state, and pthread_join(). Establishes the thread lifecycle model that all synchronisation topics build upon.

Lesson 2 • Read-Write Locks and Barriers

Covers rwlock for read-heavy workloads and pthread_barrier for phase synchronisation. Extends the synchronisation toolkit to patterns where exclusive locking is too coarse.

Lesson 3 • Condition Variables

Demonstrates pthread_cond_wait(), spurious wakeups, and the predicate loop pattern. Enables threads to efficiently wait for state changes without busy-waiting.

Lesson 4 • Mutexes and Critical Sections

Teaches mutex initialisation, lock/unlock discipline, and error-checking mutex types. Provides the primary tool for protecting shared data from concurrent modification.

Lesson 1 • Non-Blocking I/O and epoll

Implements an event-driven server using non-blocking sockets, epoll_create(), and edge-triggered mode. Scales connection handling beyond the one-thread-per-connection model.

Lesson 2 • Socket API Fundamentals

Covers socket(), bind(), listen(), accept(), connect(), and address structures for IPv4 and IPv6. Establishes the core API surface all network programming builds upon.

Lesson 3 • UDP and Datagram Sockets

Covers sendto(), recvfrom(), and connectionless communication patterns for UDP. Contrasts UDP's unreliable delivery with TCP and identifies appropriate use cases.

Lesson 4 • Socket Options and Advanced Features

Teaches getsockopt()/setsockopt() for tuning buffers, keepalive, and Nagle algorithm control. Enables fine-grained performance and reliability tuning of network connections.