This comprehensive guide explores the Linux kernel’s architecture, core subsystems, source‑tree layout, and dynamic module management while offering practical learning paths, essential command‑line tools, code examples, and curated reading material for anyone aiming to master operating‑system internals.
This article explains what memory barriers are, why they are essential for correct multi‑core operation in the Linux kernel, how different barrier types work, their implementation details, and practical guidelines for using them safely in synchronization primitives and driver code.
Steve Klabnik, a veteran of Rust and Ruby on Rails, explores a new system programming language called Rue that aims for memory safety without garbage collection, leveraging Anthropic’s Claude AI for rapid development and discussing its design trade‑offs, progress, and future prospects.
This article walks through every stage a packet undergoes inside the Linux kernel—from the moment an application calls write() or send() to the final recv() call—covering socket handling, routing, ARP/NDP resolution, queuing, NIC offloads, and reassembly with concrete commands and code examples.
This article explains how Linux’s Netlink mechanism provides efficient, full‑duplex communication between kernel space and user space, overcoming the limitations of ioctl, /proc, and system calls, and details its architecture, data structures, API usage, and real‑world applications.
Google’s ambitious eight‑year roadmap for the experimental Carbon language aims to create a modern, safer, C++‑compatible system language, detailing its tooling, ecosystem, migration strategy via FFI, and why it’s preferred over Rust despite the long development horizon.
This comprehensive guide explores Linux inter‑process communication (IPC), explaining why processes need to communicate, the underlying kernel mechanisms, and detailed coverage of pipes, FIFOs, signals, files, shared memory, message queues, and sockets with practical code examples and real‑world use cases.
In an interview, Vivo’s BlueOS team explains why they built their operating system with Rust, detailing the language’s safety and performance benefits, the challenges of adoption, the measurable gains in reliability and maintenance, and the learning curve developers faced.
This comprehensive guide explains why and how to compile a custom Linux kernel, covering the benefits for performance, hardware support, and security, the full build process on Ubuntu, configuration options, installation steps, debugging tools, and common troubleshooting techniques for developers and system administrators.
This guide outlines a step‑by‑step roadmap for aspiring kernel developers, covering essential knowledge foundations, hands‑on teaching‑OS projects, deep‑dive strategies for reading the real Linux kernel source, and curated book recommendations to build solid OS internals expertise.
This article explains the fundamentals of the mmap system call, its internal working mechanism, zero‑copy I/O model, advantages, typical use cases, and detailed usage guidelines—including function prototypes, parameter meanings, mapping steps, and sample code—while also exploring how mmap‑mapped files behave during program crashes.
From powering cutting‑edge 3A games and operating system kernels to accelerating scientific simulations, high‑frequency trading, and embedded IoT devices, C++ remains the go‑to language for high‑performance, low‑level control across diverse domains, thanks to its speed, portability, and fine‑grained memory management.
This article traces the evolution of Linux I/O from blocking and non‑blocking models through epoll to the modern io_uring framework, explains its design goals, core concepts, system‑call workflow, and provides practical code examples and performance comparisons for high‑concurrency network and storage applications.
This article presents a comprehensive, difficulty‑ordered list of 60 small Linux C/C++ projects—ranging from basic command‑line tools to advanced system‑level components—designed to help developers practice core programming concepts, system programming, networking, concurrency, and performance optimization.
This article explores how the C language enables low‑level hardware control by detailing the roles of CPU registers and physical memory, illustrating direct register access via inline assembly, and explaining pointer usage for memory manipulation, highlighting the trust C places in programmers and the responsibilities it entails.
Linux treats all I/O devices as files, enabling a single thread to monitor many descriptors via I/O multiplexing; while select and poll use linear scans and suffer size limits, epoll employs an event‑driven red‑black tree with edge‑triggered mode, offering scalable, high‑performance handling for thousands of concurrent connections.
The 2024 Rust State Survey reveals improved developer productivity but persistent challenges like slow compilation, debugging difficulty, and limited industry adoption, highlighting concerns over complexity, low usage in tech, and the uncertain future of Rust in the Linux kernel.
This comprehensive guide explains how Python can interface with C dynamic link libraries using the ctypes module, covering installation, data types, pointer manipulation, buffer creation, DLL loading, function calling, Windows API interactions, and practical code examples for system-level programming.
Most operating systems are written in C because its simple, portable syntax, minimal runtime, and direct memory and hardware access let developers write bare‑metal kernels that manage resources efficiently, making C the preferred high‑level language for system programming despite other languages being better for applications.
This article explains Linux core dump generation, common causes such as null pointer dereference and array overflow, configuration steps, and demonstrates how to analyze core files using GDB with practical code examples and multi‑threaded case studies.
This article presents a collection of handy C code snippets that demonstrate how to quickly obtain struct member sizes and offsets, read CPU temperature, determine file sizes, fetch system timestamps, retrieve MAC and IP addresses, perform file I/O, display progress bars, format log output, and enable core dump generation, each accompanied by sample usage and expected results.
This article explains how Linux zero‑copy techniques—DMA, sendfile, splice, mmap + write, and tee—reduce CPU involvement in large file and network transfers by moving data directly within kernel space, detailing their workflows, code examples, performance trade‑offs, and suitable use cases.
This guide walks developers with C and assembly experience through building a simple bare‑metal operating system that runs directly on ARM64 hardware without any existing OS or bootloader, offering a hands‑on introduction to low‑level system concepts for students, embedded engineers, and computer‑system enthusiasts.
Processes represent execution contexts that include code and resources; to avoid wasteful busy‑waiting, operating systems let them sleep and later wake them, using mechanisms like schedule_timeout_interruptible, timers, and try_to_wake_up, which the Linux kernel implements through specific state changes and scheduling logic.
This tutorial explains how to use Python's ctypes library to register, implement, and remove a low‑level keyboard hook on Windows by calling the necessary WinAPI functions from user32.dll and kernel32.dll, providing complete example code and step‑by‑step guidance.
This article introduces a new book 'Deep Understanding of Linux Processes and Memory' that systematically explains CPU, memory, and process scheduling principles, covering hardware fundamentals, virtual memory, Golang coroutines, container resource management, and performance optimization techniques.
The article examines the recent Windows BSOD crisis caused by a faulty CrowdStrike update, argues that memory‑unsafe languages like C/C++ contributed to the failure, and explains how Microsoft and the industry are turning to the memory‑safe Rust language for system, firmware, and cloud components to improve reliability and security.
This guide explains why zombie processes appear in Linux, demonstrates how to reproduce them with sample code, shows how to identify them using ps, discusses the system risks they pose, and provides proper cleanup techniques using wait/waitpid and parent termination.
The article offers a comprehensive analysis of memory‑safety concerns, weighing the economic, technical, and practical factors that influence whether developers should replace C/C++ with safer languages like Rust, and explains why the decision is far more complex than a straightforward security upgrade.
Linux kernel 6.9 introduces Rust support on AArch64, expanded hardware drivers, performance and security enhancements, new network capabilities, and significant filesystem updates, while Torvalds highlights timer subsystem rewrites and previews the upcoming 6.10 merge window.
Explore Rust arrays in depth—from declaration syntax and element access to iteration, mutable updates, built‑in methods, multidimensional structures, and a practical fixed‑size stack implementation—highlighting their performance‑focused design and safety guarantees for system programming.
This article explains how integrating Go with assembly language can overcome Go's performance and low‑level control limits for system and driver development, covering basic concepts, integration methods, multi‑CPU architecture support, practical code examples, and the resulting performance and portability benefits.
This article walks through a Go example that uses the os, os/exec, and syscall packages to locate the ls binary, set arguments and environment, and then replace the current process with ls via syscall.Exec, explaining each step and its practical implications.
This article provides an in‑depth overview of QEMU, covering its purpose as a virtual machine monitor and emulator, installation methods, core command‑line tools, internal architecture, TCG dynamic translation, KVM interaction, and memory‑management structures for building and running virtual machines.
This article outlines eight key domains where C is still widely used—including embedded systems, desktop applications, system components, operating systems, language compilers, signal processing, audio/video handling, and databases—highlighting typical projects, tools, and why C remains essential for low‑level, performance‑critical development.
Microsoft is accelerating the migration of its Windows core and Microsoft 365 services from C# to Rust, hiring senior architects to lead the Substrate platform team and promising massive performance and size gains for cloud‑scale systems.
A comprehensive collection of over 100 Linux system and kernel interview questions, covering topics such as distributions, package management, process monitoring, memory management, file systems, system calls, concurrency, C/C++ language features, data structures, algorithms, and practical code examples for developers preparing for technical interviews.
This article explains why Zig, with its built‑in build system, package manager, safety features, and modern language design, is emerging as the most compelling replacement for C in system programming, offering high performance, easy C interop, and a promising future for developers.
The 18th China Linux Kernel Developer Conference (CLK 2023) will be held in Shenzhen on October 28, 2023, hosted by OPPO, and invites Linux kernel developers to submit technical papers (open call from September 22, deadline October 10) on topics such as architecture, scheduling, memory, storage, networking, virtualization, performance, testing and kernel use in IoT, mobile, automotive, cloud and AI, with required author bio, title and abstract.
Zig combines a lightweight, C‑compatible syntax with a built‑in build system, package manager, and safety features, positioning it as a compelling, hardware‑friendly successor to C for system programming, cross‑compilation, and modern software development, while offering seamless C interop and robust tooling.
This article explains the nsenter command, its purpose for entering Linux container namespaces, detailed option flags, usage syntax, and practical examples for debugging container networking and other namespaces, while also covering the underlying concepts of namespaces, clone, and setns.
VAL is a newly created high‑level programming language designed for system and edge computing, offering near‑Rust performance while avoiding references, and targeting applications like operating systems, games, and image processing that cannot afford virtual machines or garbage collectors.
This comprehensive guide walks beginners through the Linux kernel’s architecture, source acquisition, configuration, compilation, installation, key subsystems, essential programming knowledge, and how to join the kernel community, providing practical code examples and curated learning resources.
This article explains what the Linux kernel is, explores its different architectures—including microkernel, monolithic, and hybrid designs—covers kernel file locations, module handling, and offers a comprehensive learning roadmap with recommended books and hands‑on advice for anyone wanting to understand operating system fundamentals.
This article explains the concept of sockets using a plug analogy, details their usage in TCP/UDP communication, explores the kernel's sock structures and inheritance tricks, and describes how sockets expose network functionality to user‑space programs through file descriptors and queues.
The article explains Android’s emerging eBPF support, detailing how to write, compile, load, attach, and debug BPF programs—including map handling, permission controls, perf‑event reporting, and practical debugging steps—while highlighting its current preliminary status and vast potential for kernel‑level monitoring on mobile devices.
Microsoft is integrating Rust into the Windows kernel to replace legacy C++ code, aiming to eliminate whole classes of memory‑safety bugs, boost performance, and set a new standard for secure system‑level development.
Linux I/O models range from synchronous native operations to asynchronous kernel‑bypass techniques, with APIs such as open, read, write, mmap, sendfile and splice, while the modern io_uring interface—supporting interrupt, polling, and kernel‑polling modes via liburing—delivers superior performance, especially at high queue depths, compared to traditional libaio.
This article introduces the Linux kernel, explains its role and different architectures—including microkernel, monolithic, and hybrid designs—covers their advantages and disadvantages, describes kernel file locations, modules, and offers practical learning tips and reference resources for system programmers.
This article explains Linux's virtual address space layout, the six user‑space memory segments, how malloc decides between brk and mmap based on allocation size, the behavior of free, and why both allocation methods are needed for performance and memory management.
This article explains what Unix signals are, categorizes reliable and unreliable signals, describes how they are generated by hardware and software, and details registration, blocking, pending states, handling functions, and practical code examples for custom signal processing.
This guide covers core Linux commands, supported file types, inter‑process communication methods, ARM exception categories, interrupt handling steps, GPIO concepts, I2C and SPI pin functions, as well as driver inspection commands, character device creation, synchronization primitives, and key kernel subsystems.
An interview with Rust creator Graydon Hoare explores the language's origins, its emphasis on speed, memory safety and concurrency, its adoption by major tech firms, and his perspective on the current state and future challenges of system programming security.
This tutorial explains how to create a Windows key‑logging spy program by registering low‑level hooks through the user32 and kernel32 DLLs, using Python's ctypes library to call the required WinAPI functions, define callback prototypes, and manage hook installation and removal.
This article provides a comprehensive overview of the Linux kernel, explaining its purpose, different kernel architectures (microkernel, monolithic, hybrid), file locations, loadable modules, and offers practical learning advice and resource recommendations for anyone seeking to grasp operating‑system fundamentals.
Hare is a newly announced system programming language by Drew DeVault that combines a static type system, manual memory management, and a minimal runtime to target operating systems, system tools, compilers, and other high‑performance low‑level tasks, with C‑like syntax but greater simplicity.
Hare is a newly announced system programming language that aims to replace C with a simple, stable, and robust design, offering static typing, manual memory management, a batteries‑included standard library, and support for multiple architectures and operating systems.
This tutorial explains Linux process concepts, how to view and identify processes, the differences between programs and processes, and provides detailed examples of using fork, vfork, wait, exec family functions, system, and popen to create, control, and monitor child processes, including handling zombies and orphans.
This article provides a step‑by‑step technical guide to implementing C++ stackful coroutines, covering the design of the owl.context API, low‑level context‑switch principles, register saving conventions on 32‑bit ARM, and complete source code for co_getcontext, co_setcontext, co_swapcontext and co_makecontext with illustrative examples and diagrams.
This article explains how Linux handles local network I/O for 127.0.0.1, detailing the differences from cross‑machine communication, the routing decisions, the loopback device driver, soft‑interrupt processing, and the complete kernel execution flow for both sending and receiving packets.
The article explains how Android’s shift to Linux kernel 4.x/5.x introduced the eBPF framework, detailing its advantages over iptables, the programming model with helper macros and maps, and its implementation in netd and HAL to collect network statistics, enforce traffic control, and support power‑saving Doze policies.
This article explains Linux's shared‑memory mechanism, covering the concepts of virtual versus physical memory, the three core system calls (shmget, shmat, shmdt), example programs for two processes, and a detailed look at the kernel structures and functions that implement shared memory.
At the recent Linaro Connect virtual conference, Linux kernel maintainer Miguel Ojeda, a Google employee, detailed the ongoing Rust for Linux project, noting existing RFC patches for Rust infrastructure and a basic virtual driver, the progress of three compiler back‑ends, and the roadmap toward integrating Rust into the kernel.
This article provides a comprehensive analysis of the Linux kernel's handling of localhost network I/O, detailing how packets destined for 127.0.0.1 bypass physical network interfaces, traverse the routing table, and utilize the loopback virtual device and soft interrupts for efficient intra-machine communication.
This article walks through the path from a Java program to the Linux kernel, detailing how the JVM is launched, how libjvm.so is loaded, how pthread_create maps to the clone system call, and what kernel resources are shared by Java threads.
This article presents the complete assembly source of the RAMinit TSR program written by Lei in 1994, explains its purpose as a hot‑key‑driven memory‑management utility for DOS, describes its interrupt‑vector handling, memory‑copy routines, and includes detailed comments that reveal the inner workings of this historic piece of system software.
This article provides a comprehensive analysis of Linux's epoll mechanism, covering its fundamental data structures, key kernel functions, wait‑queue handling, event insertion, wake‑up logic, and the differences between edge‑triggered and level‑triggered modes, while including full source code excerpts for reference.
Zero‑copy techniques in Linux eliminate unnecessary data copying between user and kernel space, dramatically reducing CPU overhead and boosting throughput; this article explains why zero‑copy is needed, outlines several methods—including user‑space I/O, mmap, sendfile, DMA‑assisted sendfile, splice, copy‑on‑write, buffer sharing, and netmap—plus their trade‑offs.
This article shares a comprehensive, experience‑based approach to learning the Linux kernel, emphasizing building a high‑level framework first, using key textbooks strategically, balancing theory with hands‑on coding, and understanding API design and hardware interactions to accelerate mastery.
This article explains the evolution of data transfer in computers—from early CPU‑bound copying to DMA, channel architectures, and I/O processors—then demonstrates how zero‑copy techniques like sendFile and memory‑mapped I/O dramatically reduce CPU usage and improve throughput.
This article explains Linux shared memory IPC, covering its data structures, system limits, essential API calls for creating, controlling, attaching, and detaching memory segments, conventions between parent and child processes, and provides a complete C example demonstrating interprocess communication.
This article provides a comprehensive tutorial on configuring KGDB on Linux, covering target and host machine preparation, kernel recompilation with debugging options, module installation, boot‑loader adjustments, and detailed remote‑gdb debugging procedures for both the kernel image and loadable modules.
This article compares Linux file locking mechanisms—flock, lockf, and fcntl—detailing their prototypes, lock types, behavior with forks, dup, exec, and NFS, and provides practical code examples illustrating differences in lock scope, recursion, and interaction between advisory and POSIX locks.
The article revisits the historic Y2K panic and explains how the same kind of overflow, known as the 2038 Unix bug, threatens Linux systems as their 32‑bit time counters will roll over on January 19, 2038, potentially causing widespread date‑related failures.
This article explains Linux asynchronous I/O (AIO), compares it with synchronous and non‑blocking I/O models, describes the underlying aiocb structure, and provides detailed examples of the AIO API functions such as aio_read, aio_write, aio_error, aio_return, aio_suspend, aio_cancel and lio_listio.
