Linux maintainer Jakub Kicinski removed roughly 4,000 lines of AppleTalk code—a networking protocol that survived 40 years—citing a flood of unreviewed AI‑generated patches that made maintenance untenable, highlighting how AI is reshaping the fate of legacy modules in open‑source projects.
The Linux 7.2 kernel removes the legacy AppleTalk networking stack—once popular on early Macs—citing decades‑old disuse, recent AI‑generated patch spam, and the maintenance burden, while preserving only minimal elements in modern protocols like Bonjour.
The article explains how OpenTelemetry eBPF Instrumentation (OBI) leverages Linux kernel eBPF probes to provide zero‑code, cross‑language observability for applications, networks, logs, and GPU workloads, detailing its protocol detection, deep runtime integration, data‑pipeline architecture, deployment options, and practical considerations.
In a candid Open Source Summit Q&A, Linus Torvalds and Dirk Hohndel discuss how AI has boosted Linux kernel commit volume by about 20%, helped uncover bugs, flooded security mailing lists with duplicate reports, and forced a shift in maintenance practices while emphasizing that AI remains a tool, not a replacement for solid engineering.
In a candid podcast conversation, Linux kernel maintainer Greg Kroah‑Hartman and Android Rust engineer Alice Ryhl explain how introducing Rust into the kernel not only forces clearer C interfaces and safer driver development but also rekindles the joy of programming for a veteran C developer.
This guide explains the four operating modes of Linux Virtual Server (LVS)—NAT, DR, TUN, and FULLNAT—detailing packet flows, configuration steps, required kernel parameters, health checks, troubleshooting tips, and best‑practice deployment scripts for building a reliable, high‑performance load‑balancing cluster.
This article explains the core principles of NUMA architecture, how it is deeply integrated into Linux kernel memory management, process scheduling, and system calls, and provides practical commands and real‑world examples to diagnose and optimize NUMA‑related performance issues.
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.
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.
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.
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.
The article explains how per‑CPU data is accessed on x86 versus ARM64, details Yang Shi’s proposal to make this_cpu_* APIs return a uniform virtual pointer across CPUs, and presents benchmark results showing up to 18% kernel sys‑time improvement and 8.5% stress‑ng speedup.
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.
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.
The newly disclosed Dirty Frag vulnerability combines CVE‑2026‑43284 and CVE‑2026‑43500 to provide a local‑privilege‑escalation chain that can turn any unprivileged user into root on all Ubuntu releases with a single command, and the article explains its mechanics, impact, and emergency mitigations.
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.
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.
The article explains why the Linux kernel reports less usable memory than the physical RAM, detailing the memblock allocator, crashkernel reservations, page‑struct overhead, and the handoff to the buddy system, showing how the kernel consumes memory for its own management.
Ubuntu 26.04 LTS (released 23 April 2026) and Fedora 44 (released 28 April 2026) are compared across kernel versions, desktop environments, X11 support, package managers, toolchains and support cycles, with guidance for newcomers, developers, enterprises and gamers on which distro best fits their needs.
A high‑severity Linux kernel flaw (CVE‑2026‑31431, dubbed "Copy Fail") allows ordinary users to gain root privileges and escape containers via an AF_ALG and splice() optimization bug, affecting major distributions; the article details the vulnerability, exploitation steps, PoC, and mitigation guidance.
The article explains the Linux kernel Seqlock mechanism—a lightweight lock‑free synchronization primitive that uses a sequence number and a spinlock to allow concurrent reads and writes, compares it with spinlocks and rwlocks, and shows real kernel and user‑space examples.
SLUB, the default Linux kernel memory allocator, reduces fragmentation and improves allocation speed for frequently created objects like task_struct and inode by using per‑CPU caches, object slabs, and NUMA‑aware node caches, with detailed structures, allocation/free paths, tuning parameters, and real‑world case studies.
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.
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.
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.
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.
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.
This comprehensive guide explores the Linux kernel’s architecture, core subsystems, source‑tree layout, and dynamic module management while offering practical learning paths, essential command‑line tools, code examples, and curated reading material for anyone aiming to master operating‑system internals.
This 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.
After months of heated debate, the Linux kernel maintainers released a three‑rule policy that permits AI‑assisted code contributions while insisting that human developers sign off, label the AI origin, and bear full responsibility for any bugs, security flaws, or licensing issues that arise.
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.
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.
Kali Linux 2026.1 arrives with a Linux 6.18 kernel, a refreshed visual theme, a nostalgic BackTrack mode, eight new security tools, significant NetHunter mobile‑pentesting enhancements, and important cautions for SDR users, while offering multiple download options for various platforms.
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.
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.
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.
Ubuntu 26.04 LTS, codenamed “Zesty Zapus,” introduces a Linux 7.0 kernel with scheduler, memory and power optimizations, GNOME 50 on Wayland, a revamped installer with visual partitioning and driver management, extensive hardware support, Chinese localization improvements, and detailed upgrade paths for various user scenarios.
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.
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 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.
This article explains how to adopt Linux kernel's struct‑array initialization and device‑tree matching techniques to implement a flexible C‑based UART driver that supports multiple compression configurations, complete with code examples and compilation guidance.
The article argues that despite the AI boom, Linux kernel engineers still face fundamental performance and memory challenges, and that most AI‑related kernel papers have little impact on mainline development because of cultural and procedural gaps between academia and the kernel community.
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.
Ubuntu 26.04 LTS introduces GNOME 50 with default VRR and a separate rendering thread, brings Rust‑based Coreutils and the first default Rust kernel drivers, upgrades to Python 3.14, GCC 16, LLVM 22 and Docker/K8s, and promises twelve years of security maintenance.
Ubuntu 26.04 LTS, codenamed Resolute Raccoon, is slated for a 23 April 2026 release and will bring GNOME 50 with VRR, Linux Kernel 6.18+ (or 6.20), Rust‑rewritten core utilities, a 12‑year support window, and an early‑access daily build for testing.
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.
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.
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.
The author details how to flash an Armbian image, modify the build scripts, compile the Linux 6.19‑rc1 kernel, and install the resulting .deb packages on a Radxa Rock5B+ board, achieving a smooth mainline boot and 4K video playback.
The article explains how batching cache‑sync operations for dma_map_sg, dma_unmap_sg and dma_sync_sg on arm64 can cut their execution time by up to three‑fold, details the kernel patches introduced, and presents benchmark results on Dimensity 9500 and RK3588 platforms.
Microsoft’s WSL 2.7.0 release upgrades the subsystem to a Linux 6.6.114 LTS kernel, adds numerous security patches, restores key environment variables, and introduces Ubuntu Pro for WSL with long‑term enterprise security updates, all detailed in the official release notes.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
The article analyzes the new swap table implementation that replaces the kernel's xarray‑based swapcache with a per‑cluster array, offering O(1) lookups, reduced lock contention, lower memory overhead, and measurable performance gains demonstrated by real‑world benchmarks.
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 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.
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.
The article explains how replacing the global mmap_lock read lock with per‑VMA locks for madvise MADV_DONTNEED/FREE removes severe lock contention and priority inversion in Linux memory management, and it details the patches, reasoning, and performance evidence supporting the change.
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.
This article explains the hardware basis of NUMA, how Linux reads ACPI SRAT/SLIT tables to discover CPU‑memory topology, the kernel functions that initialize NUMA structures, and how tools like numactl can be used to optimize application performance on multi‑node servers.
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.
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.
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.
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.
This guide explains how to create a custom Android boot animation using frame sequences, package it correctly, compress it, replace it via ADB, and also covers modifying or hiding the Linux kernel and bootloader logos, including required tools, file formats, and safety precautions.
This article provides an in‑depth analysis of BPF maps—explaining their design principles, core features, various map types with code examples, and the macro expansion process that turns high‑level BCC helpers into native kernel map definitions for cloud‑native observability.
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.
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.
This article explains the hardware basis of NUMA, how Linux reads ACPI SRAT and SLIT tables to discover CPU‑memory topology, the kernel functions that initialize NUMA structures, and how the memblock allocator incorporates this information to enable performance‑optimizing tools like numactl.
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.
This article explains eBPF from a developer's perspective, covering the eBPF virtual machine, instruction encoding, bytecode generation with LLVM/Clang, loading via the bpf() syscall, verifier rules, execution flow, JIT compilation, and how Android builds and packages eBPF programs.
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.
The article explains how the Linux kernel decides the CPU for a newly woken task, detailing the roles of wake_affine and select_idle_sibling, the influence of cache topology, run‑queue load, and various idle‑checking heuristics, with concrete examples and code snippets.
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.
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.
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.
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.
The article explains how memory pools reduce allocation overhead and fragmentation by pre‑allocating large memory blocks, describes their implementation in C++ and the Linux kernel, compares various pool designs, and shows practical scenarios where pools improve performance and stability.
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.
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.
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.
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.
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.
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.
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.
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.
The 2024 Rust State Survey reveals improved developer productivity but persistent challenges like slow compilation, debugging difficulty, and limited industry adoption, highlighting concerns over complexity, low usage in tech, and the uncertain future of Rust in the Linux kernel.
This 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.
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.
