BestHub
Sign in
Tagged articles
332 articles
Page 1 of 4
Deepin Linux
Deepin Linux
May 20, 2026 · Fundamentals

Mastering ramfs and tmpfs: Deep Dive into Linux’s High‑Speed In‑Memory Filesystems

This article explains the inner workings of Linux’s ramfs and tmpfs memory file systems, covering kernel page‑cache and shmem mechanisms, allocation and reclamation processes, size and inode limits, swap interaction, practical mounting commands, and suitable use‑cases compared with traditional disk‑based file systems.

IO performanceLinux kernelmemory file system
0 likes · 32 min read
Mastering ramfs and tmpfs: Deep Dive into Linux’s High‑Speed In‑Memory Filesystems
Deepin Linux
Deepin Linux
May 19, 2026 · Fundamentals

Master the Linux fasync Mechanism and Understand Signal‑Driven Asynchronous Notification

This article explains the Linux kernel fasync mechanism, compares it with other I/O models, details the underlying data structures and key functions, and provides step‑by‑step driver and user‑space code examples for implementing signal‑driven asynchronous notifications in embedded and Linux driver development.

Linux kernelSIGIOasynchronous notification
0 likes · 35 min read
Master the Linux fasync Mechanism and Understand Signal‑Driven Asynchronous Notification
Deepin Linux
Deepin Linux
May 17, 2026 · Fundamentals

Why Wait Queues Matter: Mastering Linux Kernel Process Sleep and Wakeup

This article explains the Linux kernel wait‑queue mechanism, detailing its data structures, sleep states, step‑by‑step process‑sleep and wake‑up procedures, core APIs, and a practical key‑driver example that demonstrates efficient blocking I/O without wasting CPU cycles.

Linux kernelblocking I/Odriver development
0 likes · 26 min read
Why Wait Queues Matter: Mastering Linux Kernel Process Sleep and Wakeup
Deepin Linux
Deepin Linux
May 15, 2026 · Backend Development

Master Linux Kernel Delay Mechanisms to Write Reliable Drivers

This article explains the different Linux kernel delay mechanisms—busy delays like udelay, sleep delays like mdelay, and high‑resolution timers—detailing their inner workings, appropriate use cases, performance trade‑offs, and common pitfalls so developers can write efficient, stable driver code for industrial‑grade systems.

Linux kerneldelay mechanismsdriver development
0 likes · 24 min read
Master Linux Kernel Delay Mechanisms to Write Reliable Drivers
Black & White Path
Black & White Path
May 13, 2026 · Information Security

Why the 90‑Day Vulnerability Disclosure Policy Is Effectively Dead

The article argues that AI‑driven discovery, rapid exploit generation, and simultaneous reporting have shattered the four original assumptions of the 90‑day disclosure window, leaving the policy obsolete as patches often lag behind public exploits and industry debates intensify.

AI securityLinux kernelexploit development
0 likes · 15 min read
Why the 90‑Day Vulnerability Disclosure Policy Is Effectively Dead
Black & White Path
Black & White Path
May 9, 2026 · Information Security

Dirty Frag: A New Deterministic Linux Page‑Cache Write Vulnerability for Stable Root Escalation

Dirty Frag is a newly disclosed Linux kernel page‑cache write bug that combines xfrm‑ESP and RxRPC primitives to deterministically corrupt struct sk_buff‑frag, allowing an unprivileged local user to gain root without race conditions, works across major distributions, and can be mitigated by disabling the affected modules.

Dirty FragLinux kernelLocal Privilege Escalation
0 likes · 9 min read
Dirty Frag: A New Deterministic Linux Page‑Cache Write Vulnerability for Stable Root Escalation
Linux Kernel Journey
Linux Kernel Journey
May 7, 2026 · Backend Development

KernelScript: A Unified Language for Full‑Stack eBPF Development

KernelScript tackles the growing complexity of eBPF projects by unifying kernel‑side programs, userspace loaders, and kernel modules into a single codebase, using annotations to let the compiler generate the necessary glue code, thereby reducing boilerplate and improving team productivity.

Compiler designKernelScriptLinux kernel
0 likes · 15 min read
KernelScript: A Unified Language for Full‑Stack eBPF Development
Black & White Path
Black & White Path
May 3, 2026 · Information Security

DeepSeek + Claude Code Reproduce CVE‑2026‑31431 Linux ‘Copy Fail’ Privilege Escalation

The author demonstrates how a human‑provided prompt combined with DeepSeek v4 Pro and Claude Code can autonomously audit the Linux 6.12 crypto subsystem, locate the CVE‑2026‑31431 “Copy Fail” privilege‑escalation bug, and validate the full exploit chain in four iterative dialogues costing less than three dollars.

AI auditingCVE-2026-31431Claude Code
0 likes · 16 min read
DeepSeek + Claude Code Reproduce CVE‑2026‑31431 Linux ‘Copy Fail’ Privilege Escalation
Java Tech Enthusiast
Java Tech Enthusiast
Apr 26, 2026 · Industry Insights

Should Legacy Open‑Source Projects Embrace AI‑Generated Code?

The article examines the split in the open‑source community over AI‑generated contributions, contrasting strict bans by projects like Vim Classic and Redox with the majority of major projects that now accept labeled AI code, and explores the resulting policy experiments, legal concerns, and security implications.

AI securityAI-generated codeLinux kernel
0 likes · 13 min read
Should Legacy Open‑Source Projects Embrace AI‑Generated Code?
Deepin Linux
Deepin Linux
Apr 25, 2026 · Fundamentals

Mastering Mutex Locks: Solving Linux Kernel Synchronization Challenges in One Article

This article provides a comprehensive deep‑dive into Linux kernel mutex locks, explaining their principles, implementation, and APIs, and demonstrates through detailed C/C++ examples how to use them safely to avoid data races, deadlocks, and performance bottlenecks in multithreaded kernel and user‑space code.

Linux kernelSynchronizationdeadlock
0 likes · 46 min read
Mastering Mutex Locks: Solving Linux Kernel Synchronization Challenges in One Article
IT Services Circle
IT Services Circle
Apr 23, 2026 · Industry Insights

Should Veteran Open‑Source Projects Embrace AI‑Generated Code?

The article examines the split in the open‑source community over AI‑generated contributions, detailing strict bans by projects like Vim Classic and Redox, the pragmatic acceptance by major projects such as Linux, a survey of 112 projects, and the implications of recent AI‑driven vulnerability discoveries.

AI contribution surveyAI-generated codeDeveloper Certificate of Origin
0 likes · 12 min read
Should Veteran Open‑Source Projects Embrace AI‑Generated Code?
Deepin Linux
Deepin Linux
Apr 23, 2026 · Fundamentals

Master Spinlock: Understand Linux Kernel Synchronization and Avoid Deadlocks

This article explains Linux kernel spinlocks—from basic concepts and atomic operations to memory barriers, busy‑waiting, and proper usage—illustrating common pitfalls like deadlocks, priority inversion, and recursion, and provides practical guidelines, code examples, and debugging tools to help developers implement safe, efficient synchronization.

C++ atomicLinux kernelLockdep
0 likes · 36 min read
Master Spinlock: Understand Linux Kernel Synchronization and Avoid Deadlocks
Black & White Path
Black & White Path
Apr 21, 2026 · Information Security

When AI Learns to Find Bugs and Write Exploits: Is a Security Singularity Arriving?

Anthropic's Claude Mythos Preview can autonomously discover zero‑day flaws in major OSes and libraries, generate fully functional exploit code without human guidance, and its demonstrated successes on OpenBSD, FFmpeg, FreeBSD NFS and the Linux kernel raise profound short‑, medium‑ and long‑term implications for the security industry.

Claude MythosFreeBSD NFSLinux kernel
0 likes · 17 min read
When AI Learns to Find Bugs and Write Exploits: Is a Security Singularity Arriving?
Deepin Linux
Deepin Linux
Apr 20, 2026 · Fundamentals

Unlocking the Linux Kernel: From Core Concepts to Hands‑On Module Development

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.

Learning ResourcesLinux kernelOperating System
0 likes · 56 min read
Unlocking the Linux Kernel: From Core Concepts to Hands‑On Module Development
MaGe Linux Operations
MaGe Linux Operations
Apr 16, 2026 · Operations

Mastering Nginx for High‑Traffic: Proven Tuning Steps for 10k+ QPS

This guide explains why the default Nginx configuration becomes a bottleneck under thousands of requests per second and provides a prioritized, production‑tested checklist of kernel, process, buffer, upstream, HTTP, and HA settings to dramatically improve throughput and latency.

ConfigurationLinux kernelNginx
0 likes · 24 min read
Mastering Nginx for High‑Traffic: Proven Tuning Steps for 10k+ QPS
Tencent Technical Engineering
Tencent Technical Engineering
Apr 12, 2026 · Operations

How TencentOS Engineers Revamped Linux Swap for 5‑20% Performance Gains

This article translates and consolidates three LWN analyses of the Linux swap subsystem modernization led by TencentOS kernel engineer Kairui Song, detailing the introduction of swap tables, removal of the swap map, virtual swap concepts, code changes, performance improvements of up to 20 % and the broader impact on the kernel community.

Linux kernelMemory ManagementPerformance Optimization
0 likes · 27 min read
How TencentOS Engineers Revamped Linux Swap for 5‑20% Performance Gains
Deepin Linux
Deepin Linux
Apr 11, 2026 · Fundamentals

Why Memory Barriers Are the Hidden Foundation of Linux Kernel Concurrency

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.

Linux kernelSynchronizationSystem Programming
0 likes · 47 min read
Why Memory Barriers Are the Hidden Foundation of Linux Kernel Concurrency
Deepin Linux
Deepin Linux
Apr 5, 2026 · Fundamentals

How Linux’s Buddy System and SLUB Allocator Power Efficient Memory Management

This article explains the core principles of Linux kernel memory management, detailing how the buddy system handles large contiguous pages while the SLUB allocator optimizes small-object allocation, and compares their performance, fragmentation handling, and real‑world usage in servers and embedded devices.

Linux kernelMemory ManagementOS fundamentals
0 likes · 43 min read
How Linux’s Buddy System and SLUB Allocator Power Efficient Memory Management
Tencent Architect
Tencent Architect
Apr 2, 2026 · Operations

How Modernizing Linux Swap Boosts Performance and Cuts Memory Overhead

This article translates and consolidates Jonathan Corbet’s three-part “Modernizing swapping” series, detailing the introduction of swap tables, removal of swap maps, and virtual swap concepts that together improve Linux kernel swap performance by up to 20%, reduce metadata memory by up to 30%, and simplify the codebase.

Linux kernelPerformance Optimizationswap map
0 likes · 27 min read
How Modernizing Linux Swap Boosts Performance and Cuts Memory Overhead
Deepin Linux
Deepin Linux
Mar 28, 2026 · Fundamentals

Unlocking Linux Performance: A Deep Dive into NUMA Architecture

This article explains the core principles of NUMA, its deep integration with the Linux kernel, practical memory‑node and scheduling mechanisms, real‑world database and virtualization use cases, and step‑by‑step commands for inspecting and tuning NUMA on modern servers.

Linux kernelMemory ManagementNUMA
0 likes · 23 min read
Unlocking Linux Performance: A Deep Dive into NUMA Architecture
Linux Kernel Journey
Linux Kernel Journey
Mar 22, 2026 · Fundamentals

Understanding EROFS: A Read‑Only Linux File System for Immutable Deployments

EROFS is a security‑focused, high‑performance read‑only Linux kernel file system designed for immutable scenarios such as container images, OS partitions, and AI model distribution, offering block‑aligned storage, minimal metadata, native compression, and host‑side page‑cache sharing to improve startup speed and reduce storage overhead.

EROFSLinux kernelcompression
0 likes · 15 min read
Understanding EROFS: A Read‑Only Linux File System for Immutable Deployments
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.

C programmingLinux kernelOperating System
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.

CVELinux kernelMemory Safety
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.

Data StructuresLinux kernelconcurrency
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.

Linux kerneldev_dbgdriver development
0 likes · 26 min read
How to Dynamically Enable dev_dbg in the Linux Kernel Without Reboot
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 kernelMemory SafetySystems Programming
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
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.

C programmingLinux kernelcoding 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 kernelSlab Allocatorkernel-development
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 kernelcache coherence
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.

BacklogConnection StatesLinux kernel
0 likes · 18 min read
Mastering TCP Connection States and Linux Backlog Tuning
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.

Linux kernelOS InternalsOperating System
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.

Bash ScriptingLinux kernelMemory Management
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 kernelTHP
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 kernelObservabilitySecurity
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.

ARM64KVMLinux kernel
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++Linux kernelallocation
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.

Linux kerneldebugfsftrace
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.

Boot ProcessLinux kernelUEFI
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 ManagementTHP
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 ManagementPerformance Optimization
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.

ARM64EL2KVM
0 likes · 13 min read
Understanding KVM Hyp Mode Memory Mapping Initialization
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.

Boot ProcessE820Linux kernel
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 StructuresExtent
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.

C programmingGarbage CollectionLinux kernel
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.

CFICode reviewLinux kernel
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.

Backend DevelopmentLinux kernelMicroservices
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.

Boot ProcessI/OLinux kernel
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 kernelbug fixkernel-development
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 kernelScheduler
0 likes · 4 min read
Stop Being a Linux Kernel Code Parrot: Think Like a Scheduler Designer