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 tribute honors the late Linux kernel developer Li Shaohua, highlighting his pivotal contributions to MD RAID, block I/O, NVMe, and storage performance, while sharing personal anecdotes and technical lessons that continue to inspire kernel engineers worldwide.
The article analyzes why Sysbench‑driven MySQL connections time out when concurrency exceeds 5 000, tracing the issue to TCP SYN‑cookie processing and a full accept queue, and proposes configuration‑level mitigations.
This article explores the motivations for analyzing Linux kernel source code and provides a comprehensive guide to navigating the 2.2.5 i386 kernel tree, detailing the boot sequence—from BIOS to real mode initialization, bootsect loader, setup, and protected‑mode startup—while highlighting key files, structures, and parameters.
This article examines the rapid adoption of 25G SmartNICs for cloud workloads, compares major vendor solutions, explains why an Open vSwitch‑based TC Flower offload design was chosen, and details the practical challenges and performance gains achieved when deploying the solution in a public‑cloud environment.
This article explains the architecture of Hadoop HDFS, identifies performance bottlenecks in page cache and metadata handling on DataNodes, and presents four practical optimization techniques—including cache‑buffer separation, barrier disabling, directory restructuring, and real‑time monitoring—demonstrating significant throughput and latency improvements in large‑scale clusters.
This article explains the classic Linux kernel list linked‑list data structure, covering its definition, file locations, core operations such as initialization, insertion, deletion, replacement, moving, splitting and merging, the list_entry macro, usage examples, and important multithreading considerations.
This article shares a personal yet systematic approach to learning the Linux kernel, emphasizing the importance of building a high‑level framework before diving into code, recommending key textbooks, discussing language considerations, API insights, and encouraging hands‑on experimentation to deepen understanding.
When clients frequently use short TCP connections they often encounter error 110 (connection timeout) and error 99 (cannot assign requested address), which stem from TIME‑WAIT port exhaustion and server listen‑queue overflow, and this article explains the causes and practical solutions.
The article explains the thundering herd problem where many processes wake for a single event, describes Linux’s kernel fixes for accept() and partial epoll solutions, and details how Nginx avoids the issue using a custom inter‑process accept mutex and lock design.
This article examines a Linux 3.10 kernel soft‑lockup bug where the ext4 extent‑status LRU spin‑lock is held for over 20 seconds under memory pressure, explains the ext4 delayed‑allocation mechanism, block lookup process, extent‑status cache shrinkage, and presents the community's mitigation approach.
This article reviews the historical C10K challenge, explains IO model improvements like epoll, kqueue and IOCP, and details practical Linux performance optimizations such as CPU and memory affinity, RSS/RPS/RFS/XPS, IRQ handling, kernel tuning, and hardware utilization for high‑concurrency servers.
The article investigates why massive Redis deployments experience network packet loss despite using 10 Gbps NICs, explains how Linux kernel counters such as net.if.in.dropped are derived from /proc/net/dev, walks through the driver‑to‑kernel processing path, and proposes CPU‑affinity, interrupt‑affinity and NUMA‑aware tuning to eliminate the drops.
Through kernel‑level analysis we discovered that Redis packet loss stemmed from rx_dropped buffer exhaustion caused by interrupt‑handling backlogs, and resolved it by assigning NIC interrupts to specific cores on one NUMA node while binding Redis processes to the other, eliminating loss under dual‑10 GbE load.
The article examines how the Linux kernel community’s low security priority, corporate‑driven projects like KSPP, and contentious politics around PaX/Grsecurity have hindered timely fixes for critical vulnerabilities such as Stack Clash and CVE‑2017‑1000370.
This article explains the purpose and mechanics of process sleep in the Linux kernel, detailing how wait queues and wake‑up functions operate, why sleeping in atomic contexts such as interrupt handlers or while holding spinlocks is unsafe, and demonstrates the resulting deadlock with a sample driver.
Learn how to enable Google’s TCP BBR congestion control algorithm on Linux kernels 4.9+, including background, performance comparison with Reno/CUBIC, detailed deployment steps on CentOS via ELRepo, and verification commands, to dramatically improve bandwidth utilization on high‑latency, lossy networks.
The article recounts a half‑year investigation of a high‑performance proxy cluster whose Docker hosts repeatedly crashed due to kernel null‑pointer dereferences, detailing log analysis, three faulty hypotheses, extensive web research, kernel and Docker upgrades, and the final operational lessons learned.
An unauthenticated remote attacker can exploit a flaw in Linux kernel versions prior to 4.5’s udp.c, using crafted UDP packets with MSG_PEEK to trigger an unsafe checksum calculation, achieving arbitrary code execution and potential privilege escalation, though the vulnerability’s impact is limited due to rare MSG_PEEK usage.
This article explains the Android boot sequence, covering the bootloader's two stages, Linux kernel initialization, the Init process, the Zygote process that spawns application instances, and the role of ServiceManager and SystemServer in bringing the Android system to a ready state.
This article breaks down the Samsung clock implementation in the Linux kernel, explaining the key fields of the clk structure, its operation callbacks, and the lookup table, while providing annotated code snippets and screenshots to illustrate each component.
In this interview, Linus Torvalds shares hard‑earned lessons on software project management, emphasizing personal responsibility, the primacy of users over code quality, the limited role of tools, and how the Linux kernel mailing list keeps contributors aligned, offering timeless advice for developers and teams.
This article analyzes the nf_conntrack table‑full issue encountered during high‑concurrency OpenStack upgrades, explains how connection tracking works and is stored in a hash table, and provides practical parameter and iptables adjustments to improve memory usage and lookup performance.
A long‑standing Linux kernel bug causes the FIB routing hash table to shrink from 256 to 2 entries when multipath routing is enabled, leading to performance degradation; the article explains the faulty macros, traces the communication with the original authors, and advises applying the upstream fix or patching locally.
This article explains the design principles of Linux kernel RCU, details the implementation of rcu_read_lock, describes how interrupt handlers update shared data safely, and clarifies when old pointers can be reclaimed using call_rcu or synchronize_rcu.
This article explains the Linux kernel’s widely used container_of macro, showing how it converts a member’s address into the containing structure’s base address through examples, typeof and offsetof usage, and demonstrates the underlying calculations with clear code snippets and illustrations.
The article explains how Linux spinlocks, originally designed for SMP systems, operate in UP kernels, why CONFIG_DEBUG_SPINLOCK changes their behavior, and which spinlock variants should be used in different interrupt and preemption contexts.
A developer discovers that clearing the entire ISR register in the RTL8139 driver masks a pending Rx interrupt, causing the first TCP SYN packet to be lost, and resolves the issue by clearing only the TxOK bit.
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 examines three common TCP issues—missing client‑side socket timeouts leading to monitor‑killed processes, excessive TIME_WAIT sockets after service failures and their kernel tunables, and 40 ms keep‑alive latency caused by Nagle and delayed ACK—explaining kernel behavior and offering practical configuration fixes.
This article explains how the Linux kernel’s layered architecture, modular design, and well‑defined subsystems such as the process scheduler, memory manager, virtual file system, and network interface enable massive volunteer collaboration, extensibility, and continuous evolution of the operating system.
Linux cgroups are a kernel feature that organizes processes into hierarchical control groups, allowing fine‑grained limits, accounting, and isolation of CPU, memory, I/O, network and devices via subsystems such as cpu, memory, cpuset, blkio, and others, and are accessed through a virtual filesystem for configuring and managing resource constraints, underpinning containers and cloud platforms.
