BestHub
Sign in
Tagged articles
333 articles
Page 2 of 4
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
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 kernelSystem Programmingprocess scheduling
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 kernelOpen Source
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 MonitoringObservability
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 kernelTCPThree-way handshake
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 kernelio_uringperformance
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
Liangxu Linux
Liangxu Linux
Sep 23, 2024 · Fundamentals

Why Did Real‑Time Linux Take 20 Years to Reach the Mainline Kernel?

After two decades of development, the PREEMPT_RT real‑time patch finally merged into the mainline Linux kernel, highlighting the technical, political, and funding challenges that delayed its inclusion and explaining the benefits of deterministic, low‑latency performance for critical systems.

Linux kernelPREEMPT_RTRTOS
0 likes · 10 min read
Why Did Real‑Time Linux Take 20 Years to Reach the Mainline Kernel?
Liangxu Linux
Liangxu Linux
Sep 17, 2024 · Fundamentals

Unlocking Automatic Module Initialization with Linux Kernel Initcall on STM32

This guide explains how to replicate Linux kernel's initcall mechanism in STM32 projects by using function‑pointer sections, modifying the linker script, and defining ordered initialization macros to replace sequential main‑function calls, enabling modular and loosely‑coupled code execution.

CInitcallLinux kernel
0 likes · 8 min read
Unlocking Automatic Module Initialization with Linux Kernel Initcall on STM32
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Sep 13, 2024 · Fundamentals

Call for Papers: 19th China Linux Kernel Developers Conference (CLK 2024)

The 19th China Linux Kernel Developers Conference (CLK 2024) in Wuhan on October 26 invites paper submissions from September 10‑25 on topics such as RISC‑V, ARM64, scheduling, memory, storage, networking, containers, AI, automotive and embedded Linux kernel optimization, with abstracts limited to 500 words and results announced September 30.

Linux kernelOS developmentOpen Source
0 likes · 4 min read
Call for Papers: 19th China Linux Kernel Developers Conference (CLK 2024)
Linux Kernel Journey
Linux Kernel Journey
Sep 12, 2024 · Fundamentals

Understanding Linux Memory Allocation: Fast Path vs. Slow Path in the Source Code

This article dissects the Linux kernel's page allocation mechanisms, explaining how alloc_pages() follows a fast‑path using low watermarks and falls back to a slow‑path that triggers kswapd, direct reclaim, and compaction, while also detailing the corresponding page‑freeing functions and their internal data structures.

Linux kernelbuddy allocatorcompaction
0 likes · 30 min read
Understanding Linux Memory Allocation: Fast Path vs. Slow Path in the Source Code
Deepin Linux
Deepin Linux
Sep 10, 2024 · Fundamentals

Comprehensive Embedded Software Interview Guide: Memory Management, IPC, DMA, Kernel Allocation, and Core Concepts

This article provides an extensive overview of embedded software fundamentals, covering heap vs. stack differences, wild pointers, DMA roles, inter‑process communication methods, memory allocation strategies, malloc vs. new, volatile usage, pointer concepts, Linux kernel locks, FreeRTOS mechanisms, stack overflow prevention, compilation stages, quick‑sort algorithm, header inclusion, CAN identifiers, struct memory optimization, STM32 interrupt handling, user‑to‑kernel transitions, and condition‑variable thundering‑herd effects.

C++DMAFreeRTOS
0 likes · 121 min read
Comprehensive Embedded Software Interview Guide: Memory Management, IPC, DMA, Kernel Allocation, and Core Concepts
Linux Kernel Journey
Linux Kernel Journey
Sep 10, 2024 · Fundamentals

How BPF Powers the Linux sched_ext Scheduler: In‑Depth Implementation and Workflow

This article provides a comprehensive technical walkthrough of Linux's sched_ext scheduler extension, explaining how BPF enables custom scheduling policies, detailing the underlying CFS and EEVDF concepts, the new SCHED_EXT class, dispatch queues, kernel configuration, and practical code examples for building and testing BPF‑based schedulers.

BPFCFSEEVDF
0 likes · 19 min read
How BPF Powers the Linux sched_ext Scheduler: In‑Depth Implementation and Workflow
Deepin Linux
Deepin Linux
Sep 9, 2024 · Backend Development

Understanding epoll: Level‑Triggered vs Edge‑Triggered Modes and Kernel Implementation

This article explains the concepts of level‑triggered (LT) and edge‑triggered (ET) event notification in Linux epoll, describes epoll's core data structures such as the red‑black tree and ready‑list, details the three main APIs (epoll_create, epoll_ctl, epoll_wait), and examines the locking and internal kernel mechanisms that enable efficient I/O multiplexing.

Event-drivenI/O MultiplexingLinux kernel
0 likes · 69 min read
Understanding epoll: Level‑Triggered vs Edge‑Triggered Modes and Kernel Implementation
Top Architecture Tech Stack
Top Architecture Tech Stack
Sep 9, 2024 · Information Security

A Developer’s Hidden Backdoor: MAC Address Modification Blocked by Intentional Code

The article recounts a real‑world incident where a device’s MAC address could not be changed because a previous engineer deliberately disabled the relevant function, discusses the discovery of the backdoor code, and examines the legal and ethical implications of such intentional vulnerabilities.

Code ReviewLinux kernelMAC address
0 likes · 4 min read
A Developer’s Hidden Backdoor: MAC Address Modification Blocked by Intentional Code
Liangxu Linux
Liangxu Linux
Aug 18, 2024 · Backend Development

Why Does the Thundering Herd Problem Still Appear with epoll? Deep Dive and Fixes

This article explains the thundering herd phenomenon in multi‑process/thread servers, details its performance costs, demonstrates the issue with accept() and epoll_wait() through C examples, explores thread‑level herd, and presents mitigation techniques such as accept mutexes, SO_REUSEPORT, and Nginx's handling.

ConcurrencyLinux kernelSO_REUSEPORT
0 likes · 20 min read
Why Does the Thundering Herd Problem Still Appear with epoll? Deep Dive and Fixes
Deepin Linux
Deepin Linux
Aug 16, 2024 · Fundamentals

Understanding Linux Kernel Oops, BUG, and Panic: Debugging Techniques and Tools

This article explains Linux kernel crash diagnostics, covering Oops messages, BUG and BUG_ON macros, the die() and panic() pathways, preparation steps for reproducing bugs, kernel configuration options for debugging, and useful memory‑debugging utilities such as MEMWATCH, YAMD, Electric Fence and strace.

Linux kernelOopsbug
0 likes · 26 min read
Understanding Linux Kernel Oops, BUG, and Panic: Debugging Techniques and Tools
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Aug 9, 2024 · Fundamentals

Linux Kernel Memory Management Locks and Optimization Case Studies

The article examines Linux kernel 6.9 memory-management locks—PG_locked, lru_lock, mmap_lock, anon_vma rwsem, mapping i_mmap_rwsem, and shrinker_rwsem—explaining their roles and presenting eight community-driven optimizations such as per-memcg lru_lock, per-VMA locks, speculative faults, and lock-less shrinker techniques to improve concurrency and performance.

LRU LockLinux kernelPage Fault
0 likes · 24 min read
Linux Kernel Memory Management Locks and Optimization Case Studies
Deepin Linux
Deepin Linux
Aug 5, 2024 · Fundamentals

Understanding Linux Kernel Memory Pools and Their Implementation

This article explains the concept, benefits, and implementation details of memory pools in the Linux kernel, covering allocation functions, design principles, common strategies, and a thread‑safe C++ memory‑pool class with example code.

C++Linux kernelallocation
0 likes · 27 min read
Understanding Linux Kernel Memory Pools and Their Implementation
ByteDance SYS Tech
ByteDance SYS Tech
Aug 5, 2024 · Operations

How Netcap Uses eBPF to Trace Kernel Network Packets and Solve Drop Issues

Netcap, an open‑source eBPF‑based kernel network capture tool from ByteDance STE, lets developers trace packets across the entire Linux network stack, filter with tcpdump syntax, and extend functionality with custom filters, dramatically improving the efficiency of diagnosing kernel packet loss problems.

DebuggingLinux kernelPacket Capture
0 likes · 11 min read
How Netcap Uses eBPF to Trace Kernel Network Packets and Solve Drop Issues
Linux Code Review Hub
Linux Code Review Hub
Jul 25, 2024 · Fundamentals

How openEuler 24.03 LTS’s Dynamic Composite Page Boosts Memory Performance

The openEuler 24.03 LTS release introduces a dynamic composite page (large folio) that retains 4 KB base‑page compatibility while enabling 64 KB page performance gains, reducing TLB misses and memory overhead, and delivering double‑digit benchmark improvements for big‑data, Kafka, MySQL, I/O and memory‑allocation workloads.

ARM64BenchmarkLinux kernel
0 likes · 11 min read
How openEuler 24.03 LTS’s Dynamic Composite Page Boosts Memory Performance
Linux Code Review Hub
Linux Code Review Hub
Jun 5, 2024 · Operations

Observing Virtio‑Net NIC Queues with eBPF: A Practical Guide

This article explains how to extend eBPF to make virtio‑net NIC queue metrics observable, walks through the front‑end send/receive flow, defines key queue indices, integrates the probes into the rtrace tool, and demonstrates fault detection with real‑time data.

Linux kernelNIC queueObservability
0 likes · 17 min read
Observing Virtio‑Net NIC Queues with eBPF: A Practical Guide
Linux Code Review Hub
Linux Code Review Hub
Jun 3, 2024 · Fundamentals

SCHED_EXT: The Extensible Kernel Scheduler Class for Custom Scheduling

The article provides a detailed technical overview of Linux's new extensible scheduler class SCHED_EXT, explaining its architecture, eBPF‑based customization interfaces, core data structures, queue management, scheduling points, and a central‑scheduler example, while comparing it with traditional CFS and per‑CPU run‑queues.

EEVDFLinux kernelScheduler
0 likes · 17 min read
SCHED_EXT: The Extensible Kernel Scheduler Class for Custom Scheduling
OPPO Kernel Craftsman
OPPO Kernel Craftsman
May 24, 2024 · Fundamentals

Linux Kernel Preemption Mechanism: Principles, Implementation, and Performance Analysis

The article examines Linux 6.1’s preemption mechanism, explaining latency sources, the three preemption configurations (none, voluntary, full), the TIF_NEED_RESCHED flag and preempt_count tracking, and how preempt_enable/disable affect real‑time responsiveness, illustrated by a case where RT threads cannot preempt CFS due to disabled preemption in critical driver code.

Linux kernelOperating SystemsPerformance Optimization
0 likes · 21 min read
Linux Kernel Preemption Mechanism: Principles, Implementation, and Performance Analysis
Deepin Linux
Deepin Linux
May 17, 2024 · Fundamentals

Comprehensive Overview of epoll Data Structures and Implementation in Linux

This article systematically explains epoll's core data structures—including a red‑black tree and a doubly linked ready list—its three main APIs, the kernel implementation details, thread‑safety mechanisms, ET vs. LT behavior, and how it improves over select/poll for high‑concurrency network programming.

Event-drivenI/O MultiplexingLinux kernel
0 likes · 68 min read
Comprehensive Overview of epoll Data Structures and Implementation in Linux
21CTO
21CTO
Apr 18, 2024 · Artificial Intelligence

GPT‑6, VAR Models, and the Latest AI Breakthroughs Shaping Tech

The article surveys recent AI and tech developments, from Sam Altman's claim that GPT‑6 will become a universal tool and Baidu's new intelligent computing OS, to Peking University and ByteDance's VAR model outperforming diffusion models, plus updates on Boston Dynamics' Atlas robot, Linux kernel Kconfig, AMD Ryzen Pro CPUs, and SQLite 3.45.3.

Artificial IntelligenceDatabaseLinux kernel
0 likes · 11 min read
GPT‑6, VAR Models, and the Latest AI Breakthroughs Shaping Tech
Liangxu Linux
Liangxu Linux
Apr 5, 2024 · Fundamentals

Why Zero‑Length Arrays Matter in Linux Kernel Development

This article explains what zero‑length arrays are, how they are defined in C, why they appear frequently in the Linux kernel as flexible array members, and provides a complete kernel‑style implementation showing creation, expansion, and cleanup of a dynamically sized integer array.

CDynamic memory allocationFlexible array member
0 likes · 10 min read
Why Zero‑Length Arrays Matter in Linux Kernel Development
MaGe Linux Operations
MaGe Linux Operations
Mar 31, 2024 · Backend Development

Mastering Tomcat Performance: Key Tuning Parameters and Best Practices

This article explains how to optimize Tomcat by adjusting server.xml parameters such as maxThreads, acceptCount, maxConnections, and connectionTimeout, while also covering related Linux kernel settings, file descriptor limits, and JVM options to achieve balanced performance for both CPU‑bound and I/O‑bound workloads.

JVMLinux kernelPerformance tuning
0 likes · 14 min read
Mastering Tomcat Performance: Key Tuning Parameters and Best Practices
Bin's Tech Cabin
Bin's Tech Cabin
Mar 28, 2024 · Backend Development

Why MappedByteBuffer Beats FileChannel (And When It Doesn’t) – Deep Linux Kernel Insights

This article examines the internal read/write mechanisms of Java's FileChannel and MappedByteBuffer on Linux kernel 5.4, compares their performance through detailed source analysis and benchmarks, and explains why MappedByteBuffer often outperforms FileChannel for small I/O but can be overtaken for larger transfers due to page‑fault and dirty‑page handling.

FileChannelJavaLinux kernel
0 likes · 28 min read
Why MappedByteBuffer Beats FileChannel (And When It Doesn’t) – Deep Linux Kernel Insights
Alibaba Cloud Big Data AI Platform
Alibaba Cloud Big Data AI Platform
Mar 18, 2024 · Operations

Build Pure‑C eBPF Projects with Native libbpf – No libbpf‑bootstrap Needed

This article walks through constructing pure‑C eBPF programs using the native libbpf library, covering kernel‑libbpf version mapping, environment setup for RPM and DEB systems, detailed Makefile analysis, embedding BPF objects via hexdump, and extending the approach to USDT and Uprobe tracing without relying on libbpf‑bootstrap.

C ProgrammingLinux kernelSystem Tracing
0 likes · 40 min read
Build Pure‑C eBPF Projects with Native libbpf – No libbpf‑bootstrap Needed
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Mar 1, 2024 · Mobile Development

GPU Frequency Scaling on Qualcomm Adreno Using the Linux devfreq Framework

Using Qualcomm’s Adreno GPU as a case study, the article explains how the Linux devfreq framework enables GPU frequency scaling by creating a kgsl devfreq device and an msm‑adreno‑tz governor, detailing their initialization, event handling, target‑frequency computation, and the kernel callbacks that apply the new rates.

AdrenoGPULinux kernel
0 likes · 5 min read
GPU Frequency Scaling on Qualcomm Adreno Using the Linux devfreq Framework
21CTO
21CTO
Feb 28, 2024 · Backend Development

What the 2023 Rust Survey Reveals About Global Adoption and Future Challenges

The 2023 Rust Survey shows modest growth in Rust usage worldwide, highlights China's 6% developer share, details tool preferences, uncovers concerns over complexity and performance, and outlines the community's top priorities for language improvements and ecosystem support.

InteroperabilityLinux kernelProgramming Language
0 likes · 7 min read
What the 2023 Rust Survey Reveals About Global Adoption and Future Challenges
Java Tech Enthusiast
Java Tech Enthusiast
Feb 17, 2024 · Information Security

Linux Kernel SandBox Mode (SBM) Patch Enhances Memory Safety

Huawei engineer Petr Tesarik submitted a Linux kernel patch that adds SandBox Mode (SBM), an API confining kernel code to predefined memory regions, using hardware paging and CPU privilege levels to isolate components, detect out‑of‑bounds accesses, recover from violations, terminate the sandbox and return error codes such as -EFAULT, enabling continued execution.

Linux kernelMemory SafetySecurity Patch
0 likes · 2 min read
Linux Kernel SandBox Mode (SBM) Patch Enhances Memory Safety
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Feb 2, 2024 · Fundamentals

Linux Shared Memory (shmem) Deep Dive: Architecture, Implementation, and Practice

Linux’s shmem subsystem provides hybrid anonymous/file‑backed pages that enable diverse shared‑memory scenarios—parent‑child communication, IPC, tmpfs, Android ashmem, and memfd—by using APIs such as shmem_file_setup, handling page faults through cache and swap mechanisms, and employing a specialized reclamation process to manage memory efficiently.

Linux kernelVirtual Memorymemfd
0 likes · 10 min read
Linux Shared Memory (shmem) Deep Dive: Architecture, Implementation, and Practice
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Jan 5, 2024 · Fundamentals

Read‑Write Semaphore (rw_semaphore) and Per‑CPU rwsem in the Linux Kernel (ARM64)

The article explains Linux kernel read‑write semaphores, detailing the classic rw_semaphore’s optimistic‑spinning and hand‑off mechanisms, then introduces the per‑CPU rwsem for ARM64, which replaces global counters with per‑CPU data and an RCU fast‑path to cut cache‑coherency traffic at the cost of losing optimistic spinning.

ARM64Linux kerneloptimistic spinning
0 likes · 12 min read
Read‑Write Semaphore (rw_semaphore) and Per‑CPU rwsem in the Linux Kernel (ARM64)
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Dec 29, 2023 · Fundamentals

Overview of Linux Kernel Synchronization Mechanisms: Atomic Operations, Spinlocks, Semaphores, and Mutexes

The article systematically explains Linux kernel synchronization primitives—from basic atomic operations through queued spinlocks, counting semaphores, and sleeping mutexes to read‑write semaphores and per‑CPU variants—detailing their underlying data structures, memory‑barrier semantics, and the fast‑path and slow‑path acquisition and release APIs.

Linux kernelSpinlockSynchronization
0 likes · 13 min read
Overview of Linux Kernel Synchronization Mechanisms: Atomic Operations, Spinlocks, Semaphores, and Mutexes
Liangxu Linux
Liangxu Linux
Nov 29, 2023 · Fundamentals

Inside Linux Cgroup CPU Subsystem: How Containers Get CPU Time Controlled

This article provides a detailed, code‑driven explanation of how Linux cgroup’s CPU subsystem manages container CPU usage, covering cgroup creation, limit configuration, kernel object relationships, scheduler integration, bandwidth enforcement, and the role of period and slack timers.

CPU schedulingLinux kernelcfs_bandwidth
0 likes · 27 min read
Inside Linux Cgroup CPU Subsystem: How Containers Get CPU Time Controlled
21CTO
21CTO
Nov 22, 2023 · Frontend Development

New UI Releases: Slint 1.3, Flutter 3.16, Rust 1.74, Notion AI, Linux Kernel

The article summarizes recent releases across UI toolkits and core platforms, covering Slint 1.3's Android support, Flutter 3.16's Impeller preview, Rust 1.74's Cargo enhancements, Notion's AI‑driven Q&A feature, and multiple Linux kernel updates addressing security and bug fixes.

FlutterLinux kernelNotion AI
0 likes · 6 min read
New UI Releases: Slint 1.3, Flutter 3.16, Rust 1.74, Notion AI, Linux Kernel
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Nov 10, 2023 · Fundamentals

Insights from the 18th China Linux Kernel Developers Conference (CLK 2023) on Enhancing China’s Open‑Source Influence

At the 18th China Linux Kernel Developers Conference in Shenzhen, nearly 500 engineers and senior experts from Tencent, Huawei, Loongson, Intel and Ant Group showcased major open‑source contributions and discussed strategies—such as corporate‑academic alliances, documentation translation and mentorship—to boost China’s code quality, trust and global influence in the Linux ecosystem.

ChinaCollaborationCommunity
0 likes · 18 min read
Insights from the 18th China Linux Kernel Developers Conference (CLK 2023) on Enhancing China’s Open‑Source Influence
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Nov 10, 2023 · Operations

Memory Compaction in the Linux Kernel: Mechanisms, Strategies, and Implementation Details

Linux’s memory compaction mitigates external fragmentation by moving movable pages, employing four strategies—direct, passive (kcompactd), proactive, and active—each invoking the compact_zone core with configurable compact_control parameters, migrate‑page and free‑page scanners, and distinct trigger and exit conditions.

Linux kernelMemory CompactionMemory Fragmentation
0 likes · 45 min read
Memory Compaction in the Linux Kernel: Mechanisms, Strategies, and Implementation Details
Deepin Linux
Deepin Linux
Nov 9, 2023 · Fundamentals

Understanding Linux Memory Mapping (mmap): API, Implementation, and Use Cases

This article explains Linux memory mapping (mmap), covering its purpose, API parameters, different mapping types, internal kernel implementation, page‑fault handling, copy‑on‑write semantics, practical use cases, and includes a complete Objective‑C example demonstrating file mapping and manipulation.

Copy-on-WriteLinux kernelPage Fault
0 likes · 27 min read
Understanding Linux Memory Mapping (mmap): API, Implementation, and Use Cases
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Nov 2, 2023 · Industry Insights

OPPO’s Kernel Tweaks: Dynamic HugePages and Scheduler Boosts for Smoother ColorOS

At the 18th China Linux Kernel Developer Conference, OPPO unveiled memory and scheduler optimizations—including a dynamic 64 KB huge‑page scheme, LRU reclamation improvements, and a latency‑aware scheduler balance—that collectively raise memory access performance by over 10 %, reduce lock contention, and lower frame‑drop and audio‑stutter rates, demonstrating the impact of programmable kernel technologies on Android smoothness.

Linux kernelMemory OptimizationMobile OS
0 likes · 7 min read
OPPO’s Kernel Tweaks: Dynamic HugePages and Scheduler Boosts for Smoother ColorOS
Network Intelligence Research Center (NIRC)
Network Intelligence Research Center (NIRC)
Oct 11, 2023 · Cloud Native

How XDP Is Redefining Network Performance Beyond Traditional Stacks

This article examines XDP (eXpress Data Path), a Linux kernel eBPF‑based technology that pushes packet processing to the earliest point in the network interface, delivering ultra‑low latency, enhanced security, and flexible custom processing for high‑performance routing, DDoS mitigation, and cloud environments.

Cloud NativeLinux kernelXDP
0 likes · 5 min read
How XDP Is Redefining Network Performance Beyond Traditional Stacks
OPPO Amber Lab
OPPO Amber Lab
Sep 26, 2023 · Fundamentals

Join the 18th China Linux Kernel Conference: Call for Papers & Event Details

The 18th China Linux Kernel Developers Conference (CLK) will take place on October 28, 2023 in Shenzhen, featuring a call for papers on topics such as hardware architectures, scheduling, memory management, storage, networking, virtualization, performance, testing, and more, with submission deadlines from September 22 to October 10.

Linux kernelOpen SourceSubmission
0 likes · 4 min read
Join the 18th China Linux Kernel Conference: Call for Papers & Event Details
Liangxu Linux
Liangxu Linux
Aug 14, 2023 · Backend Development

Mastering GNU C Extensions: typeof, Zero‑Length Arrays, and More in the Linux Kernel

This article explains key GNU C extensions used in the Linux kernel—including typeof, zero‑length (flexible) arrays, case ranges, labeled initializers, variadic macros, function and variable attributes, built‑in functions, asmlinkage, and UL suffixes—showing why they exist, how to use them safely, and providing concrete code examples.

GNU CLinux kernelbuiltin function
0 likes · 13 min read
Mastering GNU C Extensions: typeof, Zero‑Length Arrays, and More in the Linux Kernel
MaGe Linux Operations
MaGe Linux Operations
Aug 11, 2023 · Operations

How eBPF Transformed Linux: From BPF Roots to Modern Observability

This article traces the evolution of eBPF from its BPF predecessor, explains its kernel requirements, security model, probe mechanisms, performance impact, tracing capabilities, and potential event‑loss risks, and looks ahead to its expanding role in networking and system observability.

Linux kernelObservabilityTracing
0 likes · 11 min read
How eBPF Transformed Linux: From BPF Roots to Modern Observability
Tencent Architect
Tencent Architect
Jul 20, 2023 · Fundamentals

Explore, Build, and Contribute: A Beginner’s Guide to the Linux Kernel

This comprehensive guide walks beginners through the Linux kernel’s architecture, source acquisition, configuration, compilation, installation, key subsystems, essential programming knowledge, and how to join the kernel community, providing practical code examples and curated learning resources.

Linux kernelSystem Programmingkernel-development
0 likes · 11 min read
Explore, Build, and Contribute: A Beginner’s Guide to the Linux Kernel
MaGe Linux Operations
MaGe Linux Operations
Jul 12, 2023 · Fundamentals

Mastering Linux Kernel Basics: A Practical Guide to Core Concepts

This article explains what the Linux kernel is, explores its different architectures—including microkernel, monolithic, and hybrid designs—covers kernel file locations, module handling, and offers a comprehensive learning roadmap with recommended books and hands‑on advice for anyone wanting to understand operating system fundamentals.

Linux kernelOS fundamentalsSystem Programming
0 likes · 26 min read
Mastering Linux Kernel Basics: A Practical Guide to Core Concepts
AI Cyberspace
AI Cyberspace
Jul 8, 2023 · Fundamentals

Understanding Virtio: The Key to Efficient I/O Virtualization in Linux

This article explains the virtio framework for para‑virtualized hypervisors, comparing full and para‑virtualization, detailing the architecture, buffer model, core API, driver examples, and future directions, providing a comprehensive overview of Linux I/O virtualization.

Device DriversI/O virtualizationLinux kernel
0 likes · 13 min read
Understanding Virtio: The Key to Efficient I/O Virtualization in Linux
Liangxu Linux
Liangxu Linux
Jul 3, 2023 · Fundamentals

What Exactly Is a Socket? From Plug Analogy to Kernel Implementation

This article explains the concept of sockets using a plug analogy, details their usage in TCP/UDP communication, explores the kernel's sock structures and inheritance tricks, and describes how sockets expose network functionality to user‑space programs through file descriptors and queues.

Linux kernelSocketSystem Programming
0 likes · 17 min read
What Exactly Is a Socket? From Plug Analogy to Kernel Implementation
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Jun 30, 2023 · Fundamentals

Understanding Linux Kernel Folio: From Page to Folio and Its Design Rationale

Linux kernel introduced the struct folio abstraction to replace ad‑hoc compound‑page tricks, giving a clear collection‑oriented representation for power‑of‑two page groups such as THP and HugeTLB, and providing dedicated APIs that eliminate naming confusion, unify reference handling, and make memory‑management code safer and easier to understand.

Linux kernelcompound pagefolio
0 likes · 15 min read
Understanding Linux Kernel Folio: From Page to Folio and Its Design Rationale
21CTO
21CTO
Jun 27, 2023 · Fundamentals

Why Big Tech Is Rewriting Kernels in Rust: Memory Safety Meets Performance

The article explores how Rust's memory‑safety and efficiency are driving major companies like Microsoft, Google, and Amazon to rewrite operating‑system components and cloud services, while also tracing Rust’s quirky origins, rapid rise in popularity, and the challenges it still faces.

AndroidLinux kernelMemory Safety
0 likes · 10 min read
Why Big Tech Is Rewriting Kernels in Rust: Memory Safety Meets Performance
Liangxu Linux
Liangxu Linux
Jun 22, 2023 · Backend Development

Mastering GNU C Extensions: typeof, Flexible Arrays, Case Ranges and More in the Linux Kernel

This article explains essential GNU C extensions used in the Linux kernel—including typeof, zero‑length (flexible) arrays, case range labels, designated initializers, variadic macros, function and variable attributes, built‑in functions, asmlinkage, and UL suffixes—showing why they matter and how to apply them safely.

AttributesC extensionsGNU C
0 likes · 13 min read
Mastering GNU C Extensions: typeof, Flexible Arrays, Case Ranges and More in the Linux Kernel
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Jun 9, 2023 · Information Security

Linux Disk Encryption Technology: FDE, FBE and eCryptfs Implementation Analysis

This article reviews Linux disk‑encryption technologies, explaining data‑at‑rest security concepts, comparing full‑disk encryption (hardware and dm‑crypt/LUKS) with filesystem‑based encryption (stacked eCryptfs and native fscrypt), and providing an in‑depth analysis of eCryptfs architecture, key management, and implementation details.

Data SecurityFBEFDE
0 likes · 20 min read
Linux Disk Encryption Technology: FDE, FBE and eCryptfs Implementation Analysis
Tencent Cloud Developer
Tencent Cloud Developer
May 31, 2023 · Cloud Computing

TencentOS "Wujing": Server Memory Multi-Level Offloading Solution for Cloud Data Centers

TencentOS “Wujing” provides a server‑memory multi‑level offloading framework that uses kernel‑side reclamation, heat‑aware page classification, SWAP balancing, and CXL promotion to shift cold pages to cheaper storage, cutting data‑center memory use by up to 50 % while preserving performance.

DAMONLinux kernelMemory Optimization
0 likes · 14 min read
TencentOS "Wujing": Server Memory Multi-Level Offloading Solution for Cloud Data Centers
OPPO Kernel Craftsman
OPPO Kernel Craftsman
May 26, 2023 · Fundamentals

Understanding Linux rwsem Read‑Write Semaphore in Kernel 5.15.81

Linux introduced the read‑write semaphore (rwsem) as a sleep lock that lets multiple readers hold the lock concurrently, improving read‑heavy workload performance, and the article details its internal state representation, acquisition paths for reads and writes, optimistic spinning, handoff mechanisms, and trade‑offs, noting that mobile kernels may need further tuning.

ConcurrencyLinux kernelSynchronization
0 likes · 22 min read
Understanding Linux rwsem Read‑Write Semaphore in Kernel 5.15.81
Tencent Architect
Tencent Architect
May 16, 2023 · Fundamentals

Optimizing Network Latency in TencentOS: Kernel SoftIRQ and ksoftirqd Tuning

This article details a systematic investigation and multi‑stage optimization of TencentOS network latency, uncovering kernel soft‑interrupt bottlenecks, proposing and upstreaming patches to net_rx_action, RPS handling, and ksoftirqd scheduling, ultimately reducing handshake failures by over 80% while sharing practical insights for Linux kernel developers.

Linux kernelOptimizationksoftirqd
0 likes · 15 min read
Optimizing Network Latency in TencentOS: Kernel SoftIRQ and ksoftirqd Tuning
Coolpad Technology Team
Coolpad Technology Team
Apr 27, 2023 · Cloud Computing

EROFS Cluster Mode Analysis in Linux Kernel 6.x

This article analyzes the EROFS cluster modes (INFLIGHT, HOOKED, FOLLOWED, FOLLOWED_NOINPLACE) in Linux kernel 6.x, explaining how they determine whether in-place I/O can be used based on the current status of pclusters in the chain.

Cloud ComputingCluster ModesEROFS
0 likes · 6 min read
EROFS Cluster Mode Analysis in Linux Kernel 6.x
Bin's Tech Cabin
Bin's Tech Cabin
Apr 11, 2023 · Fundamentals

How Linux Kernel Builds Slab Caches: A Deep Dive into kmem_cache Creation

This article walks through the Linux kernel's slab allocator, explaining how kmem_cache and kmem_cache_node structures are created, how slab objects are laid out in memory, how the required number of pages is calculated, and how the allocator is bootstrapped to avoid circular dependencies.

Linux kernelkernel-developmentkmem_cache
0 likes · 64 min read
How Linux Kernel Builds Slab Caches: A Deep Dive into kmem_cache Creation
Liangxu Linux
Liangxu Linux
Mar 18, 2023 · Fundamentals

Mastering GNU C Extensions: typeof, Zero‑Length Arrays, Case Ranges and More in the Linux Kernel

This article explains key GNU C extensions used throughout the Linux kernel—including typeof, zero‑length (flexible) arrays, case range labels, designated initializers, variadic macros, function and variable attributes, built‑in functions, asmlinkage and UL suffixes—showing why they exist and how to apply them safely with concrete code examples.

GNU CLinux kernelbuiltins
0 likes · 13 min read
Mastering GNU C Extensions: typeof, Zero‑Length Arrays, Case Ranges and More in the Linux Kernel
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Mar 17, 2023 · Operations

Understanding Synchronization Mechanisms and RCU in the Linux Kernel

Linux kernel synchronization requires protecting shared mutable state from concurrent access using primitives such as spinlocks, mutexes, read‑write locks, or lock‑less techniques like RCU, which copies data and waits for a grace period, each offering distinct performance, latency, and complexity trade‑offs.

ConcurrencyLinux kernelRCU
0 likes · 26 min read
Understanding Synchronization Mechanisms and RCU in the Linux Kernel
MaGe Linux Operations
MaGe Linux Operations
Feb 1, 2023 · Fundamentals

Understanding Linux Kernel Types: Micro, Monolithic, and Hybrid Explained

This article introduces the Linux kernel, explains its role and different architectures—including microkernel, monolithic, and hybrid designs—covers their advantages and disadvantages, describes kernel file locations, modules, and offers practical learning tips and reference resources for system programmers.

Hybrid KernelLinux kernelMonolithic Kernel
0 likes · 25 min read
Understanding Linux Kernel Types: Micro, Monolithic, and Hybrid Explained
Efficient Ops
Efficient Ops
Jan 29, 2023 · Operations

How Linux Kernel Handles TCP Connections: Deep Dive into sock_common and Lookup

This article explores Linux kernel TCP connection handling by examining socket data structures, port range and file descriptor tuning, core functions like tcp_v4_rcv, and lookup mechanisms, while offering practical tips to boost client-side concurrent connections beyond traditional limits.

Linux kernelOperationsPerformance tuning
0 likes · 9 min read
How Linux Kernel Handles TCP Connections: Deep Dive into sock_common and Lookup
ByteDance SYS Tech
ByteDance SYS Tech
Jan 13, 2023 · Fundamentals

How HVO Cuts HugeTLB Memory Overhead by Up to 99% in Linux Kernels

This article, based on ByteDance STE’s 2022 Linux Kernel Developer Conference talk, explains the HVO (HugeTLB vmemmap Optimization) feature that dramatically reduces struct page memory for huge pages, details its latest enhancements, cross‑architecture support, usage steps, performance trade‑offs, and future plans.

ARM64HVOHugeTLB
0 likes · 13 min read
How HVO Cuts HugeTLB Memory Overhead by Up to 99% in Linux Kernels
Open Source Linux
Open Source Linux
Jan 12, 2023 · Fundamentals

Why Intel’s Linear Address Masking (LAM) Was Rejected from Linux 6.2

Intel’s Linear Address Masking (LAM) feature, which repurposes unused bits of 64‑bit virtual addresses for metadata, was proposed for Linux 6.2 but faced strong criticism from Linus Torvalds and was ultimately not merged, prompting Intel to rewrite the code for a future kernel release.

Intel LAMLinux kerneladdress masking
0 likes · 5 min read
Why Intel’s Linear Address Masking (LAM) Was Rejected from Linux 6.2
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Jan 6, 2023 · Fundamentals

CFS Group Scheduling: Purpose, Configuration, and Kernel Implementation Details

The article explains why Linux’s Completely Fair Scheduler introduced group scheduling, how Android configures task groups via cpu.shares and Process.java, and details the kernel structures (task_group, sched_entity, cfs_rq) and algorithms for weight calculation, load measurement, propagation, and hierarchical load balancing.

CFS schedulingLinux kernelcgroup
0 likes · 28 min read
CFS Group Scheduling: Purpose, Configuration, and Kernel Implementation Details
Bilibili Tech
Bilibili Tech
Dec 27, 2022 · Operations

Optimizing QUIC Gateway Performance with AF_XDP

Bilibili’s video CDN replaced its traditional TCP‑based gateway with a QUIC/HTTP‑3 gateway and, to curb the extra CPU load caused by complex UDP handling, adopted AF_XDP kernel‑bypass sockets that redirect packets via XDP, cutting CPU usage by about half, raising peak bandwidth to roughly 9 Gbps and improving per‑bandwidth efficiency by up to 30 %.

AF_XDPLinux kernelQUIC
0 likes · 14 min read
Optimizing QUIC Gateway Performance with AF_XDP
Top Architect
Top Architect
Dec 26, 2022 · Operations

An Introduction to eBPF: Concepts, Use Cases, and Practical Examples

This article provides a comprehensive overview of eBPF, explaining its origins, core concepts, comparison with SystemTap and DTrace, common use cases such as network monitoring, security filtering, and performance analysis, and includes step‑by‑step Python examples with BCC for tracing and latency measurement.

BCCLinux kernelNetwork Monitoring
0 likes · 21 min read
An Introduction to eBPF: Concepts, Use Cases, and Practical Examples
Selected Java Interview Questions
Selected Java Interview Questions
Dec 4, 2022 · Backend Development

Linux Kernel Rejects Xiaomi Engineer’s UFS File‑Based Optimization Patch

A Xiaomi engineer submitted a set of Linux kernel patches to implement JEDEC’s UFS File‑Based Optimization (UFS FBO) for better storage performance, but kernel maintainer Christoph Hellwig harshly criticized the proposal as completely misguided and unrelated to the kernel, making acceptance unlikely.

File-Based OptimizationLinux kernelPatch rejection
0 likes · 3 min read
Linux Kernel Rejects Xiaomi Engineer’s UFS File‑Based Optimization Patch
MaGe Linux Operations
MaGe Linux Operations
Nov 22, 2022 · Operations

Why Kubernetes Pods Fail with “Resource temporarily unavailable” – Understanding PID Limits

This article analyzes a Kubernetes‑Docker environment where Java pods encounter “fork: Resource temporarily unavailable” errors, tracing the issue through kernel event logs, ulimit settings, PID limits, and related sysctl parameters, and provides detailed recommendations for kernel and user‑level configuration to prevent such failures.

DockerKubernetesLinux kernel
0 likes · 23 min read
Why Kubernetes Pods Fail with “Resource temporarily unavailable” – Understanding PID Limits
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Nov 18, 2022 · Information Security

Evolution of Linux Kernel Security Technologies from 2010 to 2022

From 2010 to 2022 the Linux kernel moved from reactive, out‑of‑tree hardening to a proactive KSPP‑driven era, integrating probabilistic and deterministic mitigations, hardware‑backed defenses, and compiler‑level checks, while Android’s adoption and emerging Rust‑based components accelerated mainstream security hardening.

AndroidGrsecurity/PaXHIDS
0 likes · 18 min read
Evolution of Linux Kernel Security Technologies from 2010 to 2022
ByteDance SYS Tech
ByteDance SYS Tech
Nov 15, 2022 · Cloud Native

How ByteDance’s STE Team Tackles Linux Kernel Memory Waste and Drives Cloud‑Native Innovation

This interview reveals how ByteDance’s STE team, a youthful group of Linux kernel engineers, identified and solved memory‑management redundancy, contributed the HVO and VDUSE projects to the open‑source community, and leveraged these advances to boost cloud‑native performance and reliability across the company.

Cloud NativeLinux kernelOpen Source
0 likes · 15 min read
How ByteDance’s STE Team Tackles Linux Kernel Memory Waste and Drives Cloud‑Native Innovation
Refining Core Development Skills
Refining Core Development Skills
Nov 13, 2022 · Fundamentals

Understanding JDK NIO File I/O and Linux Kernel Mechanisms: Buffered vs Direct IO, Page Cache, and Dirty Page Management

This article provides a comprehensive analysis of how JDK NIO performs file read and write operations by examining the underlying Linux kernel mechanisms, including the differences between Buffered and Direct IO, the structure and management of the page cache, file readahead algorithms, and the kernel parameters governing dirty page writeback.

Buffered IODirty Page WritebackFile I/O
0 likes · 78 min read
Understanding JDK NIO File I/O and Linux Kernel Mechanisms: Buffered vs Direct IO, Page Cache, and Dirty Page Management