This article presents a systematic, hypothesis-driven methodology for tuning Linux kernel parameters to improve Nginx concurrency, covering file descriptor limits, listen queue configuration, network buffer tuning, and safe canary deployment with rollback procedures, all validated through metrics and load testing.
This article analyzes CVE-2026-98432, where Go 1.24's default MPTCP enablement on tcp4 listeners triggers a Linux kernel use-after-free vulnerability, allowing remote root code execution; it explains the kernel flaw, demonstrates detection via ss -M, and provides mitigation steps including GODEBUG=multipathtcp=0 and kernel upgrades.
Linus Torvalds argues that banning AI coding tools is as absurd as banning compilers, emphasizing that engineering competence lies in understanding and responsibility, not tool avoidance, while warning that AI lowers code generation cost but not comprehension, testing, or maintenance burdens.
A detailed troubleshooting case study where random microservice disconnections in a Spring Cloud Alibaba cluster were traced to a Linux kernel bug causing JVM hangs, resolved by upgrading the kernel on affected servers.
OpenAI deployed a specialized cybersecurity model and AI agent pipeline to automatically discover, validate, and exploit 948 local privilege escalation vulnerabilities in the Linux kernel within 10 days at a cost of $1.2 million, revealing novel attack techniques and raising concerns about asymmetric defense costs.
OpenAI's October 2024 scan using an updated model uncovered 948 reproducible Linux kernel privilege escalation vulnerabilities at an average cost of $1,279 each, a fivefold increase over prior runs, with 74.7% of 2,308 candidates verified and patches submitted upstream within 10 days.
This article details CVE-2026-98432, a CVSS 9.8 use-after-free in the Linux kernel's IPv4 TCP connection handling, explains its discovery via AI, tracks fix status across distributions, describes Ubuntu's -proposed repository, and provides a three-step command sequence to manually upgrade kernels on Ubuntu 22.04, 24.04, and 26.04 LTS from the proposed channel.
Linus Torvalds advocates for ECC memory in personal workstations, explaining how silent bit flips corrupt data undetected, detailing ECC's error-correction mechanism, hardware ecosystem barriers, DDR5 On-Die ECC confusion, Linux's RAS/EDAC subsystem, and when developers should invest in ECC for reliable long-running workloads.
This article explains how Docker uses Linux cgroups to implement CPU isolation, detailing the --cpus parameter for setting CPU limits, clarifying that allocated CPUs are not fixed to specific cores but dynamically scheduled, and emphasizing that isolation prevents any single container from monopolizing all CPU resources.
Linux kernel 7.4's merge window recorded nearly 20,000 commits — a 50% jump over the usual 15,000 — with AI-generated fixes arriving during normal development instead of the stabilization phase, a shift Linus Torvalds calls a 'much healthier model,' though maintainers often rewrite AI-suggested patches.
This article compares Fedora 45 and Ubuntu 26.10 across nine dimensions including kernel versions (7.2 vs 7.3), console replacement (fbcon to kmscon), RPM forced signing, ptrace restrictions, secrets service (oo7), support cycles, upgrade models, NVIDIA driver ease, container tools, immutable desktops, and hardware support, concluding with recommendations for beginners, enthusiasts, and servers.
New Kbuild patches and AI-driven compiler optimizations have cut Linux kernel defconfig build times to ~15 seconds on a 128-core AMD EPYC server — a ~30% gain without RAM disks — while allmodconfig builds approach two minutes; future Zen 6 and PCIe 6.0 hardware could push standard builds under 10 seconds.
Phoronix benchmarks reveal Linux kernel defconfig compilation dropped to ~15 seconds on dual AMD EPYC 9575F servers (128 cores) thanks to Kbuild optimizations by Lorenzo Stoakes, including AI-assisted bottleneck analysis, with allmodconfig down to 134 seconds; next-gen hardware may push defconfig under 10 seconds.
Linus Torvalds, after calling AI 90% hype, used Claude Code to implement an RCU-based fix for Linux kernel page cache contention that tripled throughput and cut cache-line bouncing by 99.6%, but kernel reviewers discovered a subtle race condition causing silent data corruption, requiring a human rewrite.
This comprehensive guide covers Linux memory fundamentals, address space layout, buddy and slab allocation algorithms, kernel/user memory APIs, page fault handling, shared memory, common C/C++ memory pitfalls, and essential monitoring tools for backend developers.
Linux 7.3 introduces AMD Zen 6 processor support, dynamic per-core energy performance preferences, rewritten GPU reset for older Radeons, system memory fallback for low-VRAM gaming, and fixes reducing KSM and zsmalloc lock latency from 705ms to 2ms, plus RISC-V extensions, Apple M3 boot support, and new hardware drivers.
ByteDance's STE team details 198 accepted Linux kernel commits in 2026 H1, including making IPI waits preemptible to cut tail latency by 90%, solving dying memory cgroups with 33 patches, restructuring HugeTLB vmemmap optimization, accelerating large memory device initialization, and adding iomap fast paths for small direct I/O, plus extensive community review participation.
Linux kernelMemory ManagementPerformance Optimization
Linus Torvalds employed Claude Code to create an 8-patch series that removes a page-cache contention bottleneck for tiny concurrent reads, boosting 8-thread throughput from ~10M to ~32M reads/sec on a laptop, but the patches delay memory reuse via RCU grace periods and still have regressions, leaving them unmerged as of October 2024.
This article explains Linux process states (TASK_RUNNING, TASK_INTERRUPTIBLE, TASK_UNINTERRUPTIBLE), the schedule() and wake_up_process() mechanisms, the lost wakeup race condition that occurs when a process checks a condition before setting its sleep state, and the correct pattern used in the Linux kernel—setting the state to interruptible before condition checking and looping with schedule()—to avoid indefinite sleep.
This article explains Error-Correcting Code (ECC) memory, how it detects and corrects single-bit errors while detecting double-bit errors, why Linus Torvalds experienced silent memory corruption in 2022, and why ECC remains rare in consumer PCs despite its critical role in data integrity for servers, databases, and long-running Linux workloads.
This article provides a comprehensive guide to Linux kernel tracing using Ftrace and kprobe, covering static and dynamic instrumentation, practical command workflows, kernel module examples, real-world debugging case studies for network latency and memory errors, and critical performance overhead considerations.
An engineer details a week-long investigation into random microservice disappearances from Nacos in a Spring Cloud Alibaba cluster, systematically ruling out memory, CPU, disk, network, Nacos server/client issues, and JVM problems before discovering a Linux kernel bug causing JVM pauses, resolved by kernel upgrade.
Canonical has accelerated Ubuntu kernel patch releases from a four-week cycle to weekly due to AI-automated vulnerability discovery overwhelming patching capacity, exemplified by a container-escape vulnerability (CVE-2026-80521) with public proof-of-concept but no patch yet for three LTS releases, prompting mitigation guidance including live patching, capability dropping, and microVM isolation.
Ubuntu 26.10 adjusts OOM scores to prioritize killing applications over critical desktop services like GNOME Shell and D-Bus, disables systemd-oomd for user sessions, and provides immediate workarounds like zram and manual OOMScoreAdjust.
This article dissects the Linux read() system call, revealing how user-space applications, the kernel, and hardware controllers collaborate via DMA to move data from disk into memory, covering parameters, return values, blocking modes, file-type differences, and the copy_to_user overhead versus mmap zero-copy.
This article explains the four Linux kernel I/O schedulers—NOOP, CFQ, Deadline, and Anticipatory—detailing their mechanisms, queue structures, priority models, and optimal use cases for traditional disks versus SSDs, with specific latency thresholds and database workload recommendations.
The article argues that AI-generated code accelerates entropy in codebases, advocating independent atomic commits—single-purpose, indivisible, independently applicable—as a critical practice, detailing four defenses: logical isolation, auditability, reduced collaboration entropy, and preventing code rot, with implementation via CI/CD, IDE tooling, and cultural metrics.
A JDK 26 commit replaced reading /proc with a Linux-specific clock_gettime bit manipulation, cutting ThreadMXBean.getCurrentThreadUserTime() latency from 11 µs to 279 ns (40x, 400x under contention), illustrating the "abstraction tax" of portable standards.
The article explains why integrating a national anti-fraud center into the Linux kernel is technically absurd and dangerous, violating kernel design principles of generality, stability, and least privilege, and how such a move would compromise security and user control.
Linus TorvaldsLinux kernelNational Anti-Fraud Center
The article explains why integrating a national anti-fraud center into the Linux kernel violates core OS principles: kernels must remain neutral, minimal, and secure; adding application-specific logic with kernel-level privileges breaks least privilege, introduces instability, and undermines the open-source consensus that keeps Linux universal.
TencentOS's Corvus AI discovered three previously unknown kernel vulnerabilities, including XFSTango (CVE-2026-80530), within 72 hours of a known vulnerability disclosure, demonstrating proactive AI-driven vulnerability hunting across multiple Linux distributions.
A team troubleshoots random microservice disappearances from Nacos in a Spring Cloud Alibaba cluster, ruling out memory, CPU, disk, network, and Nacos client issues before discovering a Linux kernel bug causing JVM pauses, fixed by kernel upgrade.
This tutorial explains Red-Black Trees, comparing them with AVL trees, detailing their five properties, three fix operations (recolor, left/right rotations), providing a Python implementation, and covering real-world uses in Java HashMap, Linux kernel, and databases, plus selection guidelines and common pitfalls.
This comprehensive guide traces the full execution path of a Linux program from user-space glibc calls through system calls into the kernel, covering process management, memory allocation, threading, I/O buffering, dynamic linking, and practical debugging techniques.
The article explains why embedding a national anti‑fraud service into the Linux kernel is unnecessary and dangerous, violating the kernel’s principles of generality, stability, minimal privilege, and the open‑source community’s consensus.
Linux 7.3‑rc1, released by Linus Torvalds, pushes the kernel past 40.98 million lines, largely due to AMD’s DCN6 header additions, yet the most impactful improvements are a Zstd decompression speed boost, the long‑awaited MGLRU fix, and new BPF enhancements, with additional benefits for AMD Zen 6, Apple Silicon, Steam Controller, Btrfs users, and hints of AI‑driven development.
CVE‑2026‑23111 is a local privilege escalation in the Linux kernel’s nf_tables subsystem caused by a reversed conditional in nft_map_catchall_activate(), where the absence of a ‘!’ leads to a use‑after‑free, enabling an attacker to chain UAF, leak kernel addresses, build a ROP payload and gain root.
Ubuntu 26.10 "Stonking Stingray" entered feature freeze on August 20, locking in five major updates—including GNOME 51, a revamped installer, the Myna AI local transcription tool, dbus‑broker, and Rust‑based components—while hinting at a possible jump to Linux kernel 7.3 and sparking debate over a slimmer GRUB that may drop Btrfs/ZFS support.
TencentOS analyzes zombie memcg root causes — page cache, shmem, and swap entries — reviews existing solutions' limitations, and proposes a dual-track approach: upstream patches for new kernels (obj_cgroup binding, swap entry fix) and a kernel module for old kernels that asynchronously reparents dying memcg pages and swap entries to online parents, preserving cache while enabling zero-restart deployment.
Linux 7.3’s merge window showcases major performance patches from Chinese teams—ByteDance slashing SMP latency to 1.5 ms, ZTE cutting a 705 ms lock to 1.44 ms, and Xiaomi improving zsmalloc speed up to 1.83×—while Linus Torvalds, aided by Gemini AI, fixed a one‑character bug in the Intel Xe driver, and the release adds features like sched_ext, AMD UALink, Rust on PowerPC, and filesystem throughput boosts, positioning 7.3 as a strong LTS candidate.
The article analyzes Linux kernel governance, showing that while Linus Torvalds serves as the final arbiter with unique judgment, a robust hierarchy of subsystem maintainers and decentralized processes ensures the kernel will continue to evolve even if he were to die, though some cultural and community risks remain.
The article dissects CVE‑2026‑53365, a Linux kernel vsock/virtio flaw that lets an unprivileged user trigger a reference‑count underflow with 1024 zero‑copy sends, chain through io_uring and vsock to overwrite /usr/bin/su’s PT_INTERP and obtain a root shell, and outlines impact, CVSS debate, patches, and detection mitigations.
Security researchers disclosed CVE‑2026‑68138, a race‑condition flaw in the Linux kernel’s qdisc rate‑table code that lets an unprivileged user gain a root shell within seconds; it affects Linux 5.1‑7.1.5, has a publicly available PoC, and can be mitigated by applying upstream patches or disabling unprivileged namespaces.
The article provides an in‑depth technical analysis of CVE‑2026‑43074, a use‑after‑free race condition in the Linux kernel’s eventpoll implementation, detailing how Anthropic’s Mythos AI discovered the flaw, the underlying RCU‑based fix, its impact, exploitation constraints, and recommended mitigation steps.
Zapscape (CVE‑2026‑64561) is a race‑condition bug in the KVM/x86 Shadow MMU that lets an attacker with L1 guest‑kernel privileges escape to the host as root, with a publicly released PoC targeting AMD nested virtualization and detailed mitigation guidance.
An AI system called Corvus AI uncovered a use‑after‑free flaw named SCTPhantom that had hidden in the Linux kernel's SCTP stack for over 18 years, enabling privilege escalation and container escape, and the fix was merged into the mainline within 11 days after discovery.
OVSwrap (CVE‑2026‑64531) is a memory‑corruption bug in the Open vSwitch kernel data‑path that has lingered for 13 years; a low‑privilege local user can trigger a length‑wrap overflow to leak pointers, read kernel memory, and decrement fsuid/fsgid to gain root across dozens of major Linux distributions, with a publicly released PoC covering ~800 x86‑64 kernel versions and detailed mitigation steps.
An AI‑driven agent uncovered a use‑after‑free flaw in the Linux SCTP stack that had lingered for 18 years, leading to a six‑line patch (CVE‑2026‑64564) that prevents local privilege escalation and container escape, with the exploit validated across multiple major distributions.
The article interviews three newly appointed core contributors—Ray community member Fan Shilun, Apache Auron committer Gui Hua‑wen, and Linux kernel maintainer reviewer Li Nan—who describe how they turned business pain points into open‑source contributions, the skills they gained, and actionable steps for engineers to start and grow in open‑source communities.
The Key Stone K3’s 16‑core RISC‑V SoC, half of which are 1024‑bit vector AI cores, forces Linux to reject mismatched cores, revealing that economic constraints make core partitioning unavoidable and that a multi‑kernel approach is the only viable solution.
After binding HFT strategy threads to a dedicated core, four sources of interference—other runnable tasks, timer ticks, RCU callbacks, and hardware interrupts—still affect latency; the article explains how isolcpus, nohz_full, rcu_nocbs and IRQ affinity can eliminate each source, shows exact kernel parameters, verification commands, and warns about common pitfalls.
The article explains that 'Cannot assign requested address' errors under high concurrency stem from slow TIME_WAIT recycling, not port exhaustion, and shows how enabling tcp_tw_reuse and tcp_timestamps instantly solves it without a restart, while warning against the deprecated tcp_tw_recycle.
Linus Torvalds clarified that the Linux kernel is not an anti‑AI project, urging anyone opposed to AI to either fork the code or leave, while emphasizing AI as a useful tool that can improve bug reporting and code review when it actually helps maintainers.
The article explains why WSL still runs a 6.18‑based kernel despite Linux 7.1 being released, detailing Microsoft’s LTS‑only policy, the out‑of‑tree patches applied to the WSL kernel, the shared‑kernel model across distributions, the six‑step update process, and how users can manually replace the kernel.
GhostLock (CVE‑2026‑43499) is a stack‑use‑after‑free bug that has existed in every major Linux distribution for over 15 years, can be triggered without special kernel configuration, and enables a high‑reliability privilege‑escalation and container‑escape chain that the authors detail step‑by‑step, including mitigation patches and a timeline of disclosure.
This article compiles a comprehensive set of 31 Java‑related architecture diagrams, covering core components such as the class loader, JVM, threading, Spring, Hibernate, as well as related technologies like Android, Linux kernel, cloud computing, and enterprise solutions, each illustrated with detailed images.
The article dissects DirtyClone, a new DirtyFrag variant (CVE‑2026‑43503) that leverages the XFRM/IPsec path to achieve local privilege escalation on Linux, outlines its impact, timeline, technical exploitation steps, and provides mitigation recommendations for affected distributions.
OBI uses Linux kernel eBPF instrumentation to automatically capture and parse all AI‑related HTTP traffic—covering LLM, embedding, vector search, rerank and MCP tool calls—producing OpenTelemetry‑compatible traces and metrics without any code changes, enabling full‑stack observability of multi‑provider AI agents across languages with only ~1% CPU overhead.
Human researcher Jaeyoung Chung uncovered the Bad Epoll kernel race‑condition (CVE‑2026‑46242) that AI model Mythos missed, demonstrating that even the most advanced AI code‑auditing tools can overlook critical vulnerabilities while human intuition and deep analysis still dominate security research.
A rare "veteran‑level" 0‑day (CVE‑2026‑43456) hidden in the Linux kernel bonding driver for 19 years allows local privilege escalation via a type‑confusion bug that requires CAP_NET_ADMIN, with a multi‑stage exploit chain, extensive impact assessment, and detailed mitigation and detection guidance.
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.
AI contribution surveyAI-generated codeDeveloper Certificate of Origin
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.
Linux kernelMemory ManagementPerformance Optimization
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.