Skip to content
Tagged articles

Linux kernel

417 articles · Page 2 of 5
Code Archaeology
Code Archaeology
Mar 12, 2026 · Backend Development

SO_LINGER Demystified: Controlling TCP Close Behavior in Linux

This article explains the SO_LINGER socket option's three closure modes, demonstrates why SO_LINGER=0 sends RST instead of FIN, and outlines Linux's preferred solutions for TIME_WAIT accumulation—connection reuse, tcp_tw_reuse, tcp_fin_timeout, and port range expansion—over abrupt connection termination.

Linux kernelSO_LINGERTCP
0 likes · 16 min read
SO_LINGER Demystified: Controlling TCP Close Behavior in Linux
Cloud Architecture
Cloud Architecture
Mar 6, 2026 · Backend Development

Ultimate Guide to Designing Nginx Architecture for 1 Million QPS

This article walks through the complete engineering process—from Linux kernel tweaks and network stack tuning to Nginx master‑worker design, layered load‑balancing, zero‑copy I/O, rate‑limiting, and OpenResty Lua extensions—demonstrating how to build a production‑grade system that reliably handles one million queries per second.

Linux kernelNginxOpenResty
0 likes · 9 min read
Ultimate Guide to Designing Nginx Architecture for 1 Million QPS
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Mar 6, 2026 · Backend Development

How to Tune Nginx for Million‑Level Concurrency: Practical Configurations

This guide explains how to configure Nginx and Linux kernel parameters to support up to a million concurrent connections, covering worker processes, connection limits, system file‑descriptor settings, caching strategies, static file handling, and key reverse‑proxy directives with concrete code examples.

Linux kernelNginxPerformance Tuning
0 likes · 5 min read
How to Tune Nginx for Million‑Level Concurrency: Practical Configurations
Code Archaeology
Code Archaeology
Mar 5, 2026 · Backend Development

Why BBR Couldn't Dethrone CUBIC as Linux's Default TCP Congestion Control

This article analyzes Google's BBR congestion control algorithm, comparing its model-driven approach with CUBIC's loss-based design, explains why BBR hasn't become Linux's default despite advantages in high-BDP and wireless scenarios, details BBRv2/v3 improvements addressing fairness and robustness, and examines the Linux kernel's congestion control framework implementation.

BBRBBRv2BBRv3
0 likes · 14 min read
Why BBR Couldn't Dethrone CUBIC as Linux's Default TCP Congestion Control
Ubuntu
Ubuntu
Feb 9, 2026 · Fundamentals

Exploring Linux Kernel 6.19: New Features and How to Upgrade Ubuntu

Linux Kernel 6.19 introduces Live Update Orchestrator, PCIe link encryption, LoongArch 32‑bit support, a new DRM Color Pipeline API, Ext4 and Btrfs filesystem improvements, and expanded Rust infrastructure, while the article provides step‑by‑step Ubuntu upgrade instructions and explains the kernel’s merge‑window and release‑candidate workflow.

6.19Linux kernelLive Update Orchestrator
0 likes · 8 min read
Exploring Linux Kernel 6.19: New Features and How to Upgrade Ubuntu
Thought Artisan
Thought Artisan
Feb 8, 2026 · Industry Insights

Stop Chasing AI-for-Kernel Papers: The Real Opportunity Is Kernel-for-AI

A veteran kernel engineer argues that while AI academia floods the field with "AI-for-kernel" papers, few reach mainline due to community conservatism and engineering gaps; instead, kernel developers should focus on "kernel-for-AI" optimizations—scheduling, memory, I/O for AI workloads—where real impact lies.

AI for kernelI/O optimizationLinux kernel
0 likes · 8 min read
Stop Chasing AI-for-Kernel Papers: The Real Opportunity Is Kernel-for-AI
Linux Tech Enthusiast
Linux Tech Enthusiast
Feb 1, 2026 · Interview Experience

Top Embedded Linux Driver Interview Questions for Major Tech Companies

This article compiles a comprehensive set of technical interview questions and concise answers covering Linux kernel‑user communication, interrupt handling, memory allocation strategies, macros, endianness, cache hierarchy, process context, DMA, virtual memory translation, debugging tools, and driver initialization, aimed at candidates preparing for embedded Linux driver roles.

Driver DevelopmentInterview questionsLinux kernel
0 likes · 16 min read
Top Embedded Linux Driver Interview Questions for Major Tech Companies
DevOps Coach
DevOps Coach
Jan 14, 2026 · Information Security

What the First Linux Kernel Rust CVE Reveals About Memory Safety

The article explains CVE‑2025‑68260, the first Rust‑based vulnerability in the Linux kernel, detailing the race condition in the rust_binder driver, why the bug proves Rust’s safety promises, and how its limited impact contrasts with countless C‑related kernel CVEs.

CVEConcurrencyLinux kernel
0 likes · 7 min read
What the First Linux Kernel Rust CVE Reveals About Memory Safety
Deepin Linux
Deepin Linux
Jan 11, 2026 · Fundamentals

Mastering Linux Kernel Linked Lists: From Theory to High‑Performance Code

This article explains the design, implementation, and practical use of the Linux kernel's intrusive linked‑list data structure, covering its core concepts, list_head definition, common macros, insertion, deletion, traversal, optimization techniques, concurrency control with RCU and memory barriers, and real‑world examples in device drivers and process scheduling.

ConcurrencyData StructuresLinked List
0 likes · 37 min read
Mastering Linux Kernel Linked Lists: From Theory to High‑Performance Code
Deepin Linux
Deepin Linux
Jan 8, 2026 · Backend Development

How to Dynamically Enable dev_dbg in the Linux Kernel Without Reboot

This article explains the purpose of dev_info, dev_dbg, and dev_err in Linux kernel logging, shows how to view their output, and provides step‑by‑step methods—including dynamic debug, kernel configuration, and module parameters—to enable or disable dev_dbg at runtime without recompiling or rebooting.

Driver DevelopmentLinux kerneldev_dbg
0 likes · 26 min read
How to Dynamically Enable dev_dbg in the Linux Kernel Without Reboot
Code Archaeology
Code Archaeology
Jan 5, 2026 · Backend Development

Netty 4.2 io_uring Configuration Options Reference

This article summarizes Netty 4.2's io_uring configuration options across system properties, IoUringIoHandlerConfig, and ChannelOptions, covering kernel requirements, ring sizing, multishot accept/recv, buffer rings, zero-copy writes, and common socket options for high-performance Linux networking.

Linux kernelNettyZero-Copy
0 likes · 11 min read
Netty 4.2 io_uring Configuration Options Reference
21CTO
21CTO
Dec 13, 2025 · Fundamentals

Rust Moves from Experimental to Core in the Linux Kernel – What It Means

At recent Linux kernel maintainer meetings, developers announced that Rust has shed its experimental label and become a permanent, core component of the Linux kernel, highlighting its growing maturity, production use, and the remaining challenges for full integration.

Linux kernelSystems Programmingmemory safety
0 likes · 4 min read
Rust Moves from Experimental to Core in the Linux Kernel – What It Means
ITPUB
ITPUB
Dec 6, 2025 · Fundamentals

How Massive Is the Linux Kernel? Inside Its 37 Million Lines of Code

The article presents a detailed overview of the Linux kernel’s astonishing growth to over 37 million lines of code, breaks down directory sizes, explains core subsystems, lists top contributors, and offers practical advice on how to approach learning this massive open‑source project.

Learning GuideLinux kernelcode size
0 likes · 13 min read
How Massive Is the Linux Kernel? Inside Its 37 Million Lines of Code
Deepin Linux
Deepin Linux
Nov 15, 2025 · Backend Development

Mastering KGDB: A Step‑by‑Step Guide to Kernel Debugging on Multi‑Core Linux

This comprehensive guide walks Linux kernel developers through KGDB fundamentals, installation, configuration, and practical debugging techniques—including serial and network setups, kernel patching, boot‑parameter tuning, and common pitfalls—enabling precise source‑level debugging of multi‑core kernel issues.

DebuggingKGDBLinux kernel
0 likes · 30 min read
Mastering KGDB: A Step‑by‑Step Guide to Kernel Debugging on Multi‑Core Linux
Code Archaeology
Code Archaeology
Nov 14, 2025 · Backend Development

Netty 4.2 IoUring Zero-Copy Send: Two CQEs Explained

This article explains how Netty 4.2 leverages Linux io_uring's zero-copy send (IORING_OP_SEND_ZC) to avoid user-kernel data copies, detailing the two completion queue events (CQEs) — I/O completion and buffer release notification — and Netty's handling logic with code examples.

CQEJavaLinux kernel
0 likes · 10 min read
Netty 4.2 IoUring Zero-Copy Send: Two CQEs Explained
vivo Internet Technology
vivo Internet Technology
Nov 12, 2025 · Fundamentals

Linux Kernel Innovations Powering the AI Agent Era – Highlights from China’s 20th CLK

The 20th China Linux Kernel Developers Conference, hosted by vivo, presented eleven technical talks covering AI‑driven kernel challenges, memory‑compression techniques, heterogeneous compression, async file‑cache management, uncached I/O, direct I/O for compressed files, parallel writeback, host‑initiated defragmentation, zoned storage, energy‑efficient I/O, and eBPF‑based CPU idle policies, each with concrete performance results and implementation details.

AIFile SystemsLinux kernel
0 likes · 12 min read
Linux Kernel Innovations Powering the AI Agent Era – Highlights from China’s 20th CLK
Linux Kernel Journey
Linux Kernel Journey
Nov 7, 2025 · Industry Insights

Celebrating 20 Years of Linux Kernel Innovation: Highlights from the 20th CLK Conference

The 20th China Linux Kernel (CLK) Conference in Shenzhen gathered nearly 500 developers on‑site and over 170,000 online viewers, showcasing five technical sub‑forums, keynote insights on AI‑driven kernel challenges, RISC‑V adoption, and a 31‑fold rise in Chinese kernel contributors, underscoring the rapid evolution of China’s kernel ecosystem.

AIChinaLinux kernel
0 likes · 13 min read
Celebrating 20 Years of Linux Kernel Innovation: Highlights from the 20th CLK Conference
Liangxu Linux
Liangxu Linux
Oct 28, 2025 · Fundamentals

Why the Linux Kernel Discourages Using typedef

The article explains the Linux kernel's warning against new typedefs, citing Linus Torvalds' preference for struct usage, coding style guidelines, and practical reasons such as readability and maintainability in a large codebase.

Linux kernelc-programmingcoding style
0 likes · 4 min read
Why the Linux Kernel Discourages Using typedef
Deepin Linux
Deepin Linux
Oct 28, 2025 · Fundamentals

Why kmalloc Is the Secret Weapon for Fast Kernel Memory Allocation

This article explains how the Linux kernel's kmalloc function provides fast, contiguous physical memory allocation using the slab allocator, covering its API, internal mechanisms, allocation flags, memory management strategies, common pitfalls, and practical kernel module examples for developers.

Linux kernelkernel-developmentkmalloc
0 likes · 73 min read
Why kmalloc Is the Secret Weapon for Fast Kernel Memory Allocation
Xiao Liu Lab
Xiao Liu Lab
Oct 27, 2025 · Operations

Boost Nginx to 100k+ Concurrent Connections: Essential Linux Kernel Tweaks

This guide explains why the default Linux kernel limits hinder Nginx performance, lists eight crucial sysctl parameters to increase port ranges, file descriptors, and connection queues, and shows how to verify and safely apply the changes for high‑concurrency workloads.

Linux kernelhigh concurrencynetwork optimization
0 likes · 7 min read
Boost Nginx to 100k+ Concurrent Connections: Essential Linux Kernel Tweaks
Linux Kernel Journey
Linux Kernel Journey
Oct 27, 2025 · Fundamentals

Exploring eBPF‑Based Programmable Memory Management in the Linux Kernel

This article examines recent efforts to make Linux kernel memory management programmable with eBPF, covering BPF‑MM patches for mTHP order, cache‑ext’s customizable LRU, FetchBPF prefetch policies, and BPF OOM hooks, and discusses their design, implementation details, and performance impacts.

LRULinux kernelMemory Management
0 likes · 8 min read
Exploring eBPF‑Based Programmable Memory Management in the Linux Kernel
MaGe Linux Operations
MaGe Linux Operations
Oct 19, 2025 · Operations

Tune Nginx for Million‑PPS: Kernel & Config Optimizations

This guide walks through step‑by‑step Nginx high‑concurrency tuning—covering Linux kernel network parameters, system limits, worker process settings, connection reuse, HTTP/2, gzip compression, benchmarking, and monitoring—enabling single‑node throughput of over one million packets per second with sub‑50 ms P99 latency.

BenchmarkLinux kernelNginx
0 likes · 17 min read
Tune Nginx for Million‑PPS: Kernel & Config Optimizations
Deepin Linux
Deepin Linux
Oct 15, 2025 · Fundamentals

Unlock Ultra‑Fast Linux I/O: How io_uring Revolutionizes Asynchronous Operations

This article explores the evolution of Linux I/O models—from blocking and non‑blocking to epoll—and introduces io_uring as a high‑performance asynchronous framework that reduces system‑call overhead, eliminates data copies, and unifies network and disk I/O for modern high‑concurrency applications.

Linux kernelZero-Copyasynchronous I/O
0 likes · 51 min read
Unlock Ultra‑Fast Linux I/O: How io_uring Revolutionizes Asynchronous Operations
Deepin Linux
Deepin Linux
Sep 6, 2025 · Fundamentals

Why Memory Barriers Are Essential for Multithreaded Programming

Memory barriers act like traffic signals for concurrent threads, enforcing a strict order of memory operations to prevent data races, cache incoherence, and compiler reordering, thereby ensuring program correctness and stability across multi‑core and multi‑processor systems.

CPU orderingLinux kernelMultithreading
0 likes · 37 min read
Why Memory Barriers Are Essential for Multithreaded Programming
Linux Kernel Journey
Linux Kernel Journey
Sep 6, 2025 · Fundamentals

From xarray to Swap Table: Streamlining Linux Swapcache Management

The article analyzes how the newly introduced swap table replaces the kernel's xarray for swapcache, offering O(1) lookups, better locality, reduced lock contention, and lower memory overhead, with benchmark results showing notable performance gains in real workloads.

Linux kernelMemory Managementswap table
0 likes · 11 min read
From xarray to Swap Table: Streamlining Linux Swapcache Management
Raymond Ops
Raymond Ops
Sep 4, 2025 · Operations

Mastering TCP Connection States and Linux Backlog Tuning

This article explains all TCP connection states, the three‑way handshake and four‑way termination, details half‑open and full‑open queues, shows how to monitor and troubleshoot listen and accept queue overflows, and lists key Linux kernel parameters for optimizing TCP performance.

Linux kernelTCPTCP handshake
0 likes · 18 min read
Mastering TCP Connection States and Linux Backlog Tuning
Code Archaeology
Code Archaeology
Aug 19, 2025 · Backend Development

Netty 4.2's io_uring bufferRing: Design, Implementation, and Performance Trade-offs

This article dissects Netty 4.2's integration of Linux io_uring's bufferRing mechanism, explaining its ring-buffer data structure, single-tail-pointer design, Netty's IoUringBufferRing encapsulation, per-connection buffer group binding, SQE submission with IOSQE_BUFFER_SELECT, CQE flag handling, and the incremental/bundle optimizations that reduce buffer waste and CQE overhead.

JavaLinux kernelNetty
0 likes · 10 min read
Netty 4.2's io_uring bufferRing: Design, Implementation, and Performance Trade-offs
21CTO
21CTO
Aug 16, 2025 · Fundamentals

Why bcachefs Was Dropped from Linux 6.17 – Linus’s Fury and COW Outlook

Linux kernel 6.17’s first release candidate arrived without any bcachefs changes, as Linus Torvalds expressed anger over delayed RISC‑V patches, while developers debate the future of the advanced COW file system, its removal from upcoming kernels, and the broader implications for Linux’s storage stack.

BcachefsCOW filesystemLinus Torvalds
0 likes · 7 min read
Why bcachefs Was Dropped from Linux 6.17 – Linus’s Fury and COW Outlook
Liangxu Linux
Liangxu Linux
Aug 7, 2025 · Fundamentals

A Complete Roadmap to Master Linux Kernel Development from Scratch

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.

Learning RoadmapLinux kernelOS Internals
0 likes · 15 min read
A Complete Roadmap to Master Linux Kernel Development from Scratch
Deepin Linux
Deepin Linux
Jul 15, 2025 · Fundamentals

How Linux’s Page Table Cache Supercharges Memory Access

This article explains the role of the page‑table cache (TLB) in the Linux kernel, describing how it speeds up virtual‑to‑physical address translation, the underlying mapping process, cache organization, replacement policies, and its impact on system performance across desktops, servers, and high‑performance applications.

Linux kernelMemory ManagementTLB
0 likes · 29 min read
How Linux’s Page Table Cache Supercharges Memory Access
dbaplus Community
dbaplus Community
Jul 7, 2025 · Fundamentals

Why Linux Kernel 6.16 Might Be the Last Release to Support Bcachefs

The article examines the heated dispute between Linus Torvalds and Bcachefs maintainer Kent Overstreet over a controversial patch submitted during the 6.16‑rc phase, explaining how kernel merge‑window rules, community reactions, and the future of Bcachefs intertwine.

BcachefsFile SystemsLinux kernel
0 likes · 12 min read
Why Linux Kernel 6.16 Might Be the Last Release to Support Bcachefs
Ops Community
Ops Community
Jul 5, 2025 · Operations

Unlock 300% Linux Performance: Proven Kernel Tuning Secrets from 10 Years of Ops

Discover how deep understanding of Linux kernel architecture, process, memory, filesystem, and network subsystems combined with practical Bash scripts can boost system performance by up to 300%, offering step‑by‑step tuning, monitoring, and debugging techniques essential for senior operations engineers.

Linux kernelMemory ManagementPerformance Tuning
0 likes · 18 min read
Unlock 300% Linux Performance: Proven Kernel Tuning Secrets from 10 Years of Ops
21CTO
21CTO
Jul 4, 2025 · R&D Management

Why Is Linux Kernel Likely to Drop Bcachefs After a Heated Clash?

The article examines the escalating dispute between Linus Torvalds and Bcachefs maintainer Kent Overstreet over a controversial patch, explains why the Linux kernel may abandon Bcachefs after version 6.16, and outlines community reactions and possible future paths for the file system.

BcachefsFile SystemsLinux kernel
0 likes · 11 min read
Why Is Linux Kernel Likely to Drop Bcachefs After a Heated Clash?
Linux Kernel Journey
Linux Kernel Journey
Jun 29, 2025 · Fundamentals

How Xavier Xia’s Persistent Optimizations Made contpte_ptep_get Faster in All Scenarios

The article chronicles Xavier Xia’s iterative patches to the Linux kernel’s contpte_ptep_get() function, showing how early‑exit logic and subsequent refinements ultimately yielded consistent performance gains across diverse dirty/young page table scenarios, backed by benchmark data that convinced skeptical reviewers.

BenchmarkLinux kernelPerformance Optimization
0 likes · 4 min read
How Xavier Xia’s Persistent Optimizations Made contpte_ptep_get Faster in All Scenarios
Deepin Linux
Deepin Linux
Jun 6, 2025 · Fundamentals

How eBPF Can Tackle Linux Memory Fragmentation and Boost Android Performance

This article explains the problem of internal and external memory fragmentation in Linux systems, introduces eBPF as a powerful tracing tool, and provides step‑by‑step guidance for building, loading, and running eBPF programs to analyze and mitigate fragmentation on both Linux and Android platforms.

AndroidBPFLinux kernel
0 likes · 22 min read
How eBPF Can Tackle Linux Memory Fragmentation and Boost Android Performance
Deepin Linux
Deepin Linux
Jun 4, 2025 · Fundamentals

Understanding and Using Kprobes for Dynamic Kernel Debugging

This article explains the concept, architecture, key data structures, registration process, implementation details, limitations, configuration steps, and practical examples of using Kprobes to dynamically instrument and debug Linux kernel functions without recompiling or rebooting the system.

Kernel InstrumentationKernel ModuleKprobes
0 likes · 25 min read
Understanding and Using Kprobes for Dynamic Kernel Debugging
Deepin Linux
Deepin Linux
May 24, 2025 · Information Security

Understanding KASAN: Kernel Address Sanitizer for Detecting Memory Errors in Linux

The article introduces KASAN, a Kernel Address Sanitizer for Linux that uses shadow memory and redzones to accurately detect out‑of‑bounds accesses, use‑after‑free, and double‑free errors, explains its underlying mechanisms, shows how to enable it in the kernel, and provides extensive example code and log analysis.

KASANKernel Address SanitizerLinux kernel
0 likes · 34 min read
Understanding KASAN: Kernel Address Sanitizer for Detecting Memory Errors in Linux
Liangxu Linux
Liangxu Linux
May 10, 2025 · Fundamentals

Single Linux Kernel Commit Delivers 40× Memory Allocation Speedup

A recent Intel‑driven Linux kernel test revealed that a single commit fixing THP‑PMD alignment boosted 1‑byte malloc throughput by 3889% (≈40×), highlighting how tiny memory‑management tweaks can dramatically improve performance despite being demonstrated on synthetic benchmarks.

Intel XeonLinux kernelPMD
0 likes · 6 min read
Single Linux Kernel Commit Delivers 40× Memory Allocation Speedup
Linux Kernel Journey
Linux Kernel Journey
Apr 23, 2025 · Industry Insights

Highlights from the 3rd eBPF Developer Conference: A Technical Recap

The 3rd eBPF Developer Conference held on April 19, 2025 at Xi'an University of Posts and Telecommunications featured 36 expert talks on eBPF advancements, network and security innovations, observability, performance optimization, a vibrant project marketplace, student projects, and provides video and PPT resources for the community.

Linux kernelSecurityconference
0 likes · 7 min read
Highlights from the 3rd eBPF Developer Conference: A Technical Recap
Linux Kernel Journey
Linux Kernel Journey
Mar 30, 2025 · Fundamentals

Analyzing KVM Misc Device Initialization and Access on Linux

This article walks through the registration of the KVM misc device in the Linux 5.9 kernel for arm64, explains how /dev/kvm is created via misc_register, and demonstrates a user‑space program that opens the device and uses an ioctl to retrieve the KVM API version, with detailed code analysis.

KVMLinux kernelarm64
0 likes · 13 min read
Analyzing KVM Misc Device Initialization and Access on Linux
Linux Kernel Journey
Linux Kernel Journey
Mar 26, 2025 · Fundamentals

Efficient Memory Management: Paging Mechanism in x86‑64 Architecture

This article explains how the x86‑64 paging mechanism maps virtual addresses to physical memory, detailing the required protection‑mode conditions, page‑table structures, control‑register settings, various paging modes (32‑bit, PAE, 4‑level, 5‑level), and provides concrete kernel code examples and address‑translation demonstrations.

4-level-pagingLinux kernelMemory Management
0 likes · 40 min read
Efficient Memory Management: Paging Mechanism in x86‑64 Architecture
Linux Code Review Hub
Linux Code Review Hub
Mar 22, 2025 · Fundamentals

Inside Linux inotify: How the Kernel Tracks File Changes

This article dissects Linux’s inotify mechanism, detailing the kernel data structures, system‑call flow, and functions that generate and deliver file‑system event notifications, complete with code walkthroughs and diagrams. It explains how read/write operations trigger event creation, how events are queued in inotify_device, and how user‑space processes retrieve them via read and poll interfaces.

File MonitoringLinux kernelevent handling
0 likes · 14 min read
Inside Linux inotify: How the Kernel Tracks File Changes
Deepin Linux
Deepin Linux
Mar 21, 2025 · Fundamentals

Understanding Memory Pools: Concepts, Implementations, and Practical Use Cases

This article explains the concept of memory pools, how they reduce allocation overhead and fragmentation compared to traditional malloc/new, describes various pool designs and Linux kernel APIs, provides multiple C and C++ implementations, and discusses performance benefits and typical application scenarios such as servers, real‑time and embedded systems.

C++ConcurrencyLinux kernel
0 likes · 40 min read
Understanding Memory Pools: Concepts, Implementations, and Practical Use Cases
Linux Code Review Hub
Linux Code Review Hub
Mar 19, 2025 · Operations

Mastering Linux Performance with ftrace: Theory, Features, and Real‑World Use Cases

This article explains why Linux dominates server workloads, introduces the built‑in ftrace tracing framework, details its diverse tracers, lightweight static instrumentation and stable design, shows how to configure and use it via debugfs, and demonstrates performance tuning and fault diagnosis with real examples while comparing it to systemTap and LTTng.

FtraceLinux kerneldebugfs
0 likes · 33 min read
Mastering Linux Performance with ftrace: Theory, Features, and Real‑World Use Cases
ITPUB
ITPUB
Mar 17, 2025 · Fundamentals

How Does a PC Boot? From Power‑On to the First Linux Kernel Instruction

This article walks through the complete boot sequence—from the UEFI firmware that runs after power‑on, through the boot manager and BootOrder variables, to the systemd‑boot loader loading initrd and the Linux kernel, explaining each component and its role in detail.

Linux kernelUEFIboot loader
0 likes · 12 min read
How Does a PC Boot? From Power‑On to the First Linux Kernel Instruction
Open Source Linux
Open Source Linux
Mar 12, 2025 · Fundamentals

How One Linux Kernel Patch Boosted Memory Allocation Speed by 40×

Recent testing of an Intel‑powered Linux kernel patch revealed that a single code change dramatically improved memory allocation throughput by nearly 40‑fold, highlighting the massive impact of fine‑tuned memory management optimizations and the importance of addressing THP and PMD alignment issues.

Linux kernelMemory ManagementPMD
0 likes · 5 min read
How One Linux Kernel Patch Boosted Memory Allocation Speed by 40×
Liangxu Linux
Liangxu Linux
Mar 9, 2025 · Fundamentals

How One Line of Code Boosted Linux Kernel Memory Allocation by 40×

A single commit to the Linux kernel aligned transparent huge pages with PMD boundaries, delivering a near‑40‑fold increase in 1‑byte malloc throughput and illustrating how precise memory‑management tweaks can dramatically improve system performance.

Linux kernelMemory ManagementPMD
0 likes · 5 min read
How One Line of Code Boosted Linux Kernel Memory Allocation by 40×
Linux Kernel Journey
Linux Kernel Journey
Mar 3, 2025 · Fundamentals

Understanding KVM Hyp Mode Memory Mapping Initialization

This article walks through the step‑by‑step initialization of KVM's hyp mode memory mapping on ARM64, covering EL2 register setup, identity mapping, page‑table allocation, stack preparation, and code section mappings required for a functional hypervisor environment.

EL2KVMLinux kernel
0 likes · 13 min read
Understanding KVM Hyp Mode Memory Mapping Initialization
Ubuntu
Ubuntu
Feb 28, 2025 · Industry Insights

Ubuntu 24.04 LTS vs 22.04: Disruptive New Features and Long-Term Support

Ubuntu 24.04 LTS (Noble Numbat) introduces a Flutter‑based installer, GNOME 46 desktop, Linux 6.8 kernel, PipeWire as the default audio server, Thunderbird 115 as the default mail client, enhanced AppArmor and frame‑pointer security, broader hardware support and an optional 12‑year Ubuntu Pro support window, marking a substantial upgrade over 22.04.

AppArmorFlutter installerGNOME 46
0 likes · 7 min read
Ubuntu 24.04 LTS vs 22.04: Disruptive New Features and Long-Term Support
Linux Kernel Journey
Linux Kernel Journey
Feb 27, 2025 · Cloud Native

Designing FUSE: From Kernel VFS to Userspace and JuiceFS Performance

This article explains the evolution of file system architecture from kernel‑level VFS to userspace via FUSE, reviews the historical role of NFS, details JuiceFS's implementation on top of FUSE, and presents benchmark results that demonstrate its high throughput and practical limitations.

FUSEJuiceFSLinux kernel
0 likes · 15 min read
Designing FUSE: From Kernel VFS to Userspace and JuiceFS Performance
21CTO
21CTO
Feb 24, 2025 · Backend Development

Why Rust Adoption Stalls in 2024 Despite Its Safety Edge

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.

2024 SurveyLinux kernelProgramming Language Adoption
0 likes · 6 min read
Why Rust Adoption Stalls in 2024 Despite Its Safety Edge
Refining Core Development Skills
Refining Core Development Skills
Feb 19, 2025 · Operations

Linux Kernel Memory Detection via E820 Mechanism

This article explains how the Linux kernel detects physical memory during boot by leveraging the E820 mechanism, where firmware reports memory ranges via interrupt 15H, enabling the kernel to map usable memory addresses for subsequent allocation.

E820Linux kernelMemory Management
0 likes · 8 min read
Linux Kernel Memory Detection via E820 Mechanism
Linux Code Review Hub
Linux Code Review Hub
Feb 12, 2025 · Fundamentals

Stop Being a Linux Kernel Code Parrot: Embrace Reality‑First Understanding

The author, with over two decades of development experience, argues that many learners treat Linux kernel code as a rote exercise instead of mapping real‑world scheduling problems to code, and outlines essential questions about task_struct management, scheduling policies, CPU placement, fairness, and universal scheduler design.

CPU SchedulingLinux kernelOperating Systems
0 likes · 5 min read
Stop Being a Linux Kernel Code Parrot: Embrace Reality‑First Understanding
Deepin Linux
Deepin Linux
Feb 7, 2025 · Fundamentals

Understanding ext4 Extent: Data Structures and B+‑Tree Mechanism

This article explains the purpose, design, and internal data structures of ext4 extents, describes how the B+‑tree indexes extents for efficient mapping of logical to physical blocks, and compares ext4’s extent mechanism with older file‑system addressing methods and other modern file systems.

B+ TreeData StructuresEXT4
0 likes · 37 min read
Understanding ext4 Extent: Data Structures and B+‑Tree Mechanism
Deepin Linux
Deepin Linux
Feb 3, 2025 · Backend Development

Understanding and Using io_uring for High‑Performance Asynchronous I/O in Linux

This article introduces Linux's io_uring framework, explains its design goals and advantages over traditional I/O models, details its core components and system calls, provides step‑by‑step implementation examples for file and network operations, and discusses performance comparisons and practical application scenarios.

Linux kernelhigh-performanceio_uring
0 likes · 43 min read
Understanding and Using io_uring for High‑Performance Asynchronous I/O in Linux
Infra Learning Club
Infra Learning Club
Jan 20, 2025 · Fundamentals

How GPU Kernel Virtualization Works: A Deep Dive into the cgpu Project

This article explains the principles of GPU kernel virtualization by analyzing the cgpu project's source code, detailing kernel interception of device operations, the driver’s file_operations, module initialization and cleanup, procfs interfaces, scheduling logic, and compilation steps on Ubuntu 22.04.

GPU virtualizationKernel ModuleLinux kernel
0 likes · 5 min read
How GPU Kernel Virtualization Works: A Deep Dive into the cgpu Project
Liangxu Linux
Liangxu Linux
Jan 16, 2025 · Fundamentals

Building a Simple malloc and Mark‑Sweep GC for the Linux Kernel

This guide walks through creating a 32‑bit Linux‑kernel memory allocator using a free‑list, implementing morecore and add_to_free_list functions, and then adding a basic mark‑and‑sweep garbage collector that scans heap, BSS, data segments and the stack to reclaim unused blocks.

Garbage CollectionLinux kernelMark‑Sweep
0 likes · 12 min read
Building a Simple malloc and Mark‑Sweep GC for the Linux Kernel
ITPUB
ITPUB
Jan 14, 2025 · Information Security

How a Microsoft Patch Nearly Crashed Linux: Code Review, CFI, and Open‑Source Lessons

A Microsoft‑submitted performance patch for the x86_64 architecture was merged into Linux kernel 6.13 without maintainer acknowledgment, breaking control‑flow integrity and nearly causing a system‑wide failure, prompting swift emergency fixes from Intel and AMD engineers and sparking a broader discussion on open‑source code‑review practices.

CFILinux kernelMicrosoft
0 likes · 5 min read
How a Microsoft Patch Nearly Crashed Linux: Code Review, CFI, and Open‑Source Lessons
Architect's Guide
Architect's Guide
Jan 9, 2025 · Backend Development

Investigation and Resolution of Random Nacos Service Deregistration in a Spring Cloud Alibaba Microservice Cluster

This article details a week‑long investigation of intermittent Nacos service deregistration in a Spring Cloud Alibaba microservice environment, describing the background architecture, multiple hypothesis tests, diagnostic commands, kernel version mismatch, and the final fix by upgrading the Linux kernel.

Linux kernelNacosSpring Cloud
0 likes · 7 min read
Investigation and Resolution of Random Nacos Service Deregistration in a Spring Cloud Alibaba Microservice Cluster
Deepin Linux
Deepin Linux
Jan 4, 2025 · Fundamentals

Early I/O Memory Mapping (early_ioremap) in the Linux Kernel

The article explains the purpose, implementation, and usage of early I/O memory mapping (early_ioremap) in the Linux kernel, detailing its initialization, fixmap foundations, code flow, and differences from regular ioremap, with examples and kernel source snippets.

I/OLinux kernelboot process
0 likes · 39 min read
Early I/O Memory Mapping (early_ioremap) in the Linux Kernel
Tencent Cloud Developer
Tencent Cloud Developer
Jan 3, 2025 · Operations

Deep Dive into Linux Kernel Page Cache Xarray: Problem, Analysis, and Optimizations

The article examines a long‑standing hidden bug in the Linux kernel’s page‑cache Xarray that caused occasional data loss with Large Folio support, details its discovery and fix by the TencentOS team, and shows how consolidating multiple tree walks into a single walk in Linux 6.10 reduced latency and improved performance by about ten percent.

Linux kernelPage Cachebug fix
0 likes · 27 min read
Deep Dive into Linux Kernel Page Cache Xarray: Problem, Analysis, and Optimizations
Linux Kernel Journey
Linux Kernel Journey
Jan 1, 2025 · Backend Development

eBPF Tailcall: 6 Common Pitfalls and How to Detect Them

The article outlines six distinct kernel‑level bugs affecting the eBPF tailcall feature across multiple Linux versions, explains the underlying causes and the commits that fixed them, and introduces a detection tool to verify whether a running kernel is affected.

BPFLinux kernelbpf2bpf
0 likes · 7 min read
eBPF Tailcall: 6 Common Pitfalls and How to Detect Them
Deepin Linux
Deepin Linux
Dec 30, 2024 · Fundamentals

Understanding NUMA Node Detection and Memory Management in the Linux Kernel

This article explains the fundamentals of NUMA architecture, how Linux detects and represents NUMA nodes, the memory zone hierarchy, allocation policies, and practical techniques such as using numactl and taskset to bind processes for optimal performance on multi‑socket servers.

Linux kernelMemory ManagementNUMA
0 likes · 22 min read
Understanding NUMA Node Detection and Memory Management in the Linux Kernel
Linux Kernel Journey
Linux Kernel Journey
Dec 25, 2024 · Fundamentals

Stop Being a Linux Kernel Code Parrot: Think Like a Scheduler Designer

The author, with over two decades of development experience, argues that learning the Linux kernel requires understanding real-world scheduling problems rather than merely copying kernel code, and outlines key questions about task_struct management, priority, preemption, CPU placement, fairness, and universal scheduler design.

CPU SchedulingLinux kerneloperating system fundamentals
0 likes · 4 min read
Stop Being a Linux Kernel Code Parrot: Think Like a Scheduler Designer
Liangxu Linux
Liangxu Linux
Dec 11, 2024 · Fundamentals

Why Do Processes Need Sleep? Inside Linux’s Sleep and Wake Mechanism

Processes must pause execution to wait for resources, and the Linux kernel provides sleep and wake mechanisms—implemented via functions like schedule_timeout_interruptible and try_to_wake_up—to efficiently relinquish CPU time, avoid busy‑waiting, and resume when resources become ready.

Linux kernelProcess SchedulingSleep
0 likes · 10 min read
Why Do Processes Need Sleep? Inside Linux’s Sleep and Wake Mechanism
Linux Kernel Journey
Linux Kernel Journey
Nov 25, 2024 · Fundamentals

Simulating MDIO Communication with GPIO on Linux

This guide explains why and how to implement MDIO over GPIO on a Linux system, covering MDIO fundamentals, Clause22/Clause45 frame structures, YT8521 PHY pinout, required kernel drivers, device‑tree configuration, log verification, and command‑line usage.

Device TreeEmbedded LinuxEthernet PHY
0 likes · 8 min read
Simulating MDIO Communication with GPIO on Linux
Liangxu Linux
Liangxu Linux
Nov 17, 2024 · Operations

Why Processes Need Sleep and Wakeup: Linux Kernel Mechanisms Explained

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.

Linux kernelProcess SchedulingSleep
0 likes · 10 min read
Why Processes Need Sleep and Wakeup: Linux Kernel Mechanisms Explained
Deepin Linux
Deepin Linux
Nov 12, 2024 · Fundamentals

Understanding Linux Memory Barriers: Types, Usage, and Implementation

This article provides a comprehensive overview of Linux memory barriers, explaining why they are needed for correct ordering of memory operations on modern multi‑core CPUs, describing the different barrier types (read, write, full), their implementation in the kernel and Java, and illustrating their use in synchronization primitives and lock‑free data structures with code examples.

CPU architectureConcurrencyLinux kernel
0 likes · 71 min read
Understanding Linux Memory Barriers: Types, Usage, and Implementation
Liangxu Linux
Liangxu Linux
Nov 4, 2024 · Fundamentals

Unlocking GNU C Extensions: Zero‑Length Arrays, Variable‑Length Arrays, and More

This guide explains key GNU C extensions—including zero‑length and variable‑length arrays, case ranges, statement expressions, typeof, variadic macros, designated initializers, built‑in functions, and attribute syntax—showing how they differ from standard ANSI C and how to use them safely in Linux kernel development.

C extensionsGNU CLinux kernel
0 likes · 10 min read
Unlocking GNU C Extensions: Zero‑Length Arrays, Variable‑Length Arrays, and More
Java Tech Enthusiast
Java Tech Enthusiast
Nov 4, 2024 · Fundamentals

Linux Kernel Patch Improves Performance by 2.6% in Intel Benchmark

Linus Torvalds merged a small patch into the Linux kernel that streamlines the 64‑bit copy_from_user() routine by skipping the costly barrier_nospec() and applying masked user‑address handling, delivering a 2.6% speedup on Intel’s “will it scale” per‑thread‑ops benchmark and slated for inclusion in the upcoming Linux 6.12 stable release.

BenchmarkLinux kernelcopy_from_user
0 likes · 4 min read
Linux Kernel Patch Improves Performance by 2.6% in Intel Benchmark
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Nov 1, 2024 · Fundamentals

Highlights of the 19th China Linux Kernel Developers Conference (CLK 2024)

The 19th China Linux Kernel Developers Conference in Wuhan on October 26, 2024 attracted over 80,000 online viewers and nearly 400 developers, showcased five technical sub‑forums—from memory and storage I/O to virtualization and scheduling—featured AI‑focused kernel talks, announced a new open‑source innovation institute, and made all materials publicly available on GitHub.

AILinux kernelMemory Management
0 likes · 9 min read
Highlights of the 19th China Linux Kernel Developers Conference (CLK 2024)
vivo Internet Technology
vivo Internet Technology
Oct 30, 2024 · Fundamentals

vivo's Linux Kernel Innovation at the 19th China Linux Kernel Developer Conference

At the 19th China Linux Kernel Developer Conference, vivo unveiled nine open‑source innovations—including DMA‑BUF DIO for AI model loading, ZHP memory compression, EROFS and f2fs filesystem enhancements, and I/O optimizations—contributing significant performance gains and demonstrating its commitment to Linux kernel advancement worldwide.

DMA-BUFEROFSF2FS
0 likes · 6 min read
vivo's Linux Kernel Innovation at the 19th China Linux Kernel Developer Conference
360 Zhihui Cloud Developer
360 Zhihui Cloud Developer
Oct 28, 2024 · Operations

How Zero‑Intrusion eBPF Transforms TCP Network Monitoring and Troubleshooting

This article explains how zero‑intrusion eBPF technology enables detailed, non‑disruptive TCP network monitoring, covering data collection interfaces, aggregation methods, implementation steps, usage limitations, and practical installation and visualization guidance for improving network performance and fault analysis.

Linux kernelNetwork MonitoringeBPF
0 likes · 9 min read
How Zero‑Intrusion eBPF Transforms TCP Network Monitoring and Troubleshooting
Linux Kernel Journey
Linux Kernel Journey
Oct 13, 2024 · Fundamentals

Unveiling the TCP Connection Process: Inside the Linux Socket System Calls

This article dissects the Linux kernel's TCP connection workflow, explaining how the three‑way handshake prevents stale SYN packets, and walks through the socket(), bind(), listen() and connect() system calls with detailed code analysis of the underlying kernel functions and data structures.

Linux kernelTCPnetwork programming
0 likes · 42 min read
Unveiling the TCP Connection Process: Inside the Linux Socket System Calls
Linux Kernel Journey
Linux Kernel Journey
Sep 30, 2024 · Cloud Native

How to Eliminate the Per‑CPU Map in XDP TCP‑Option Parsing

This article walks through removing the per‑CPU map used to pass the TCP‑option offset in an XDP program, shows the required code changes, explains the verifier errors that arise, and presents the final fix using an int offset with a bitwise mask.

BPF verifierLinux kernelTCP options
0 likes · 8 min read
How to Eliminate the Per‑CPU Map in XDP TCP‑Option Parsing
Deepin Linux
Deepin Linux
Sep 28, 2024 · Fundamentals

Understanding io_uring: Linux Asynchronous I/O Framework and Its Implementation

This article provides a comprehensive overview of Linux's io_uring, explaining its design goals, shared‑memory mechanism, submission and completion queues, core system calls, performance advantages over traditional I/O models, typical use cases, and includes a complete example of a network server built with io_uring.

Linux kernelShared Memoryio_uring
0 likes · 39 min read
Understanding io_uring: Linux Asynchronous I/O Framework and Its Implementation
BirdNest Tech Talk
BirdNest Tech Talk
Sep 26, 2024 · Operations

How to Trace Linux Packet Drops with eBPF and kfree_skb_reason

This article explains why packets are dropped in Linux, introduces the kfree_skb_reason API added in kernel 5.17, and shows step‑by‑step how to use bpftrace to capture drop reasons, five‑tuple details, and stack traces for precise network debugging.

Linux kernelbpftraceeBPF
0 likes · 9 min read
How to Trace Linux Packet Drops with eBPF and kfree_skb_reason
21CTO
21CTO
Sep 24, 2024 · Backend Development

Why Rust Could Revolutionize Linux Kernel Development – Insights from RustConf

At RustConf, Miguel Ojeda highlighted the challenges and optimism surrounding the Rust for Linux project, explaining how unstable Rust features, developer hesitancy, and industry interest shape the effort to make Rust a safe, second language for kernel development.

Linux kernelRustSystems Programming
0 likes · 5 min read
Why Rust Could Revolutionize Linux Kernel Development – Insights from RustConf