Under Jason Donenfeld’s leadership, Linux kernel’s random number generator was overhauled in versions 5.17 and 5.18, replacing SHA1 with BLAKE2s and shifting from per‑NUMA to per‑CPU structures, delivering up to a 131% speed increase and an astonishing 8450% boost in getrandom() performance on multi‑core systems.
This article explains how Linux handles local network I/O for 127.0.0.1, detailing the differences from cross‑machine communication, the routing decisions, the loopback device driver, soft‑interrupt processing, and the complete kernel execution flow for both sending and receiving packets.
On arm64 Linux kernels (e.g., 5.10.27), the mlock system call marks VMAs with VM_LOCKED, forces page faults, sets the PG_mlocked flag and moves pages into the unevictable LRU so they cannot be reclaimed, while munlock clears these flags and returns pages to regular LRU lists, guaranteeing resident memory for latency‑sensitive applications.
This article provides an in‑depth overview of Linux memory architecture, including address spaces, segmentation and paging, memory allocation strategies such as the buddy and slab allocators, kernel and user‑space memory pools, DMA considerations, common pitfalls, and practical tools for monitoring and optimizing memory usage.
This article systematically explains the Linux driver ecosystem by covering the bus‑device‑driver model, the role of device trees in decoupling hardware description from driver code, and step‑by‑step guidance for creating a custom development board with full DTS and kernel integration.
The 2021 Linux roundup covers Richard Stallman's surprising return, Arch Linux's new installer script, Microsoft Edge arriving on Linux, the rise of CentOS alternatives, the Steam Deck's Linux‑based OS, Epic's Easy‑Anti‑Cheat Linux support, GNOME 40's redesign, kernel 5.15 native NTFS support, Linux turning 30, Linus Tech Tips' 30‑day Linux challenge, Asahi Linux's progress on Apple M1, and the impact of Windows 11 on Linux adoption.
The article explains the vague but important upstream/downstream terminology in Linux, illustrating its meaning with ISP traffic, kernel development, distribution packaging, application maintenance, and package‑manager automation, and shows why understanding data flow direction matters for developers and maintainers.
This article explains the reasons behind Linux's sophisticated memory management, covering virtual memory mechanisms, page tables, MMU/TLB interactions, page fault handling, the layout of a process's address space, glibc's malloc internals, memory reclamation techniques, and the OOM killer's decision process.
This article explains why Linux routing is essential for container networking, details how routing works during packet transmission and reception, explores routing tables and lookup mechanisms in the kernel, and provides practical commands for enabling forwarding, inspecting, modifying, and testing routing rules.
A concise roundup of the most impactful Linux events of 2021, covering Richard Stallman's comeback, Arch Linux's new installer script, Microsoft Edge's stable Linux release, CentOS alternatives, Steam Deck's Linux base, anti‑cheat support, GNOME 40, native NTFS driver, Linux's 30th anniversary, Linus Tech Tips' desktop experiment, Apple M1 Linux progress, and the implications of Windows 11.
The article reveals the recovered 1994 Linus Torvalds presentation, highlights Linux 5.16's performance gains for AMD mobile CPUs, discusses upcoming Linux security initiatives such as SBOM and Rust adoption, and warns of compatibility challenges as Chrome approaches version 100.
As 2021 draws to a close, this roundup highlights twelve pivotal Linux developments—from Richard Stallman's controversial return and Arch Linux’s new installer to Microsoft Edge on Linux, the rise of CentOS alternatives, Steam Deck’s Arch‑based OS, native NTFS support, and the celebration of Linux’s 30th anniversary—each reshaping the ecosystem for users and developers alike.
This article provides a comprehensive overview of Linux's core components—including the kernel, shell, virtual file system, memory and process management, device drivers, networking, and disk partitioning—explaining their roles, structures, and how they interact within the operating system.
This article provides a comprehensive overview of Linux system architecture, covering the kernel, memory and process management, virtual and physical filesystems, device drivers, networking, shell types, file types, directory structures, partitioning, mounting, and link mechanisms, all illustrated with diagrams and command examples.
During high‑traffic events like Double‑11, Linux systems often see load averages surge, affecting response times and command execution; this article explains what load averages represent, how the kernel computes them using exponential weighted moving averages, and outlines common causes and systematic methods for root‑cause analysis.
This guide presents twenty practical Linux server optimization methods—from kernel elevator tuning and daemon reduction to TCP tweaks, secure backups, and effective monitoring commands—helping administrators enhance reliability, speed, and security while reducing resource consumption.
IBM’s early‑stage CPU Namespace prototype introduces a new Linux kernel namespace that virtualizes logical CPU IDs, enabling containers to see isolated CPU resources, improving consistency, security, and fairness, with test results showing up to 95% memory usage reduction and 64% latency drop without affecting throughput.
This article explains the purpose and functions of file systems, describes logical and physical file structures, introduces Linux's virtual file system architecture and its core data structures such as superblocks, inodes, dentries and file objects, and details the path‑lookup process used by the kernel when opening files.
This article explains the technical details of Linux kernel preemption, covering the difference between preemptible and non‑preemptible kernels, the role of the reschedule flag and preempt count, scheduling checkpoints and preempt points, low‑latency handling in non‑preemptible kernels, and the voluntary preemption model.
This article explains the Linux graphics display stack, covering FBDEV, DRM/KMS, V4L2, framebuffer memory layout, CRTC, plane, encoder/connector structures, ioctl registration, the component framework for device initialization, and how to use the libdrm‑provided modetest tool.
Linux 5.15, the latest LTS kernel announced by Linus Torvalds, introduces Paragon’s NTFS3 driver, expanded AMD, Intel, and Apple hardware support, resolves the controversial -Werror policy, and is accompanied by Google’s unprecedented bounty program rewarding security researchers for critical kernel vulnerabilities.
This article explains how Linux network namespaces provide isolated network stacks by using virtual Ethernet devices, kernel data structures, and per‑namespace routing and iptables, offering step‑by‑step commands, code excerpts, and deep insight into the kernel mechanisms that enable container networking isolation.
This article explains the complete Linux startup sequence, covering BIOS power‑on self‑test, interrupt vector initialization, MBR and partition table layout, multi‑stage bootloaders such as GRUB, kernel decompression, transition to protected mode, and the init system with runlevels.
This article explains how Linux bridge and virtual Ethernet (veth) devices work together to enable communication between Docker containers, covering the creation of network namespaces, veth pairs, bridge setup, kernel implementation details, and packet forwarding processes.
This article explains the nature of the 127.0.0.1 loopback address, why pinging it works without a physical network connection, the differences between 127.0.0.1, localhost and 0.0.0.0, and how the kernel processes loopback traffic using a virtual network interface.
This guide explains how Linux processes share physical memory using the shmget, shmat, and shmdt system calls, detailing their prototypes, parameters, example programs, kernel structures, and the internal workings of the associated kernel functions.
This article explains the inner workings of KernelAddressSanitizer (KASAN) in the Linux kernel, covering how to enable it, the shadow‑memory mechanism, redzone handling for heap, global and stack allocations, and how to interpret the detailed KASAN bug reports generated at runtime.
This article explains how Linux allocates memory for a process, the role of OOM when memory runs out, where different types of memory reside, the behavior of shared and private mappings, tmpfs usage, and both manual and automatic memory reclamation mechanisms.
This article explains Linux kernel memory management by covering process address space layout, allocation mechanisms, OOM killer behavior, overcommit settings, various types of file and anonymous mappings, tmpfs usage, and both manual and automatic memory reclamation techniques.
The article explains the Linux kernel boot process on ARM platforms, covering how the bootloader loads and decompresses the gzipped kernel image, the entry points of the compressed zImage, the early serial output, the initialization of the MMU and page tables, and the transition to the main C kernel code.
This article explains the layered architecture of the Linux network subsystem, the TCP/IP model implementation, how hardware and soft interrupts are registered and processed, the role of ksoftirqd and NAPI, and the complete send/receive packet flow from NIC to protocol stack.
A Chinese tech blogger retrieved the Android kernel source from UMIDIGI after a GPLv2 violation controversy, documented the process in a YouTube video, and made the code publicly available for developers to review.
This article explains the Linux kernel's process for selecting a client-side TCP port during connect() and bind(), covering the relevant source code, random port selection algorithm, conflict checks, and common error scenarios such as "Cannot assign requested address".
Linux cgroups are a kernel mechanism that groups processes into hierarchical directories, each subsystem (e.g., freezer, CPU, memory, IO) exposing control files such as cgroup.procs and freezer.state, with core data structures like cgroup_subsys, cgroup, css_set linking threads to multiple subsystems and enabling resource policies, freezing, throttling, and allocation.
This article explains the layered architecture of the Linux network stack, maps the TCP/IP model to Linux implementation, and details how hardware and soft interrupts, ksoftirqd threads, and NAPI cooperate with driver initialization to process packet reception and transmission.
This tutorial walks you through the Linux kernel source layout, required build tools, cross‑compilation setup, how to compile a kernel image, generate device‑tree blobs, build standalone .ko modules, and integrate those modules into a custom kernel for ARM boards.
This article explains the complete kernel‑level implementation of the TCP three‑way handshake, covering server listen queue allocation, client connect state handling, SYN/SYN‑ACK processing, syncookie protection, timer management, socket creation, and the accept path, with detailed code examples.
The Linux community announced the first release candidate of the 5.14 kernel, featuring contributions from about 1,650 developers, over 13,000 commits, new memfd_secret system call, extensive driver and architecture updates, and numerous core subsystem enhancements.
This article explains how Docker leverages Linux namespaces to isolate system resources, outlines the six core namespaces and newer additions, clarifies common misconceptions such as the Mount namespace flag, and details the internal nsproxy structure that links processes to their namespaces.
This article explains why Linux uses virtual IRQ numbers, describes the irq_domain framework and its data structures, compares linear, tree, and no‑mapping strategies, and walks through the complete interrupt‑mapping process on an ARM64 platform with code examples.
This article explains the object‑oriented design of the Linux VFS, details the four core VFS structures, shows how ext4 is registered and mounted via register_filesystem and ext4_mount, and walks through the six‑step ext4_fill_super process for initializing superblocks and related metadata.
This article explains the four core parts of a Linux system—kernel, shell, filesystem and applications—covering memory and process management, VFS architecture, file types, directory hierarchy, partitioning, mounting, links and essential command‑line tools.
On Linux, the client port used in a TCP connection is selected either by the kernel during the connect system call—randomly scanning the ip_local_port_range while respecting reserved ports—or by a prior bind call, with detailed kernel functions such as inet_hash_connect and __inet_hash_connect governing the process.
The article walks through Linux’s mmap file‑read workflow—from the kernel entry point and VMA creation, through page‑fault handling that allocates pages and invokes synchronous or asynchronous readahead, to munmap’s unmapping steps and the deferred file‑cache reclamation mechanisms.
An intermittent 403 error caused by nginx reuseport misrouting on a shared IP was traced to kernel listener hash table ordering; upgrading the Linux kernel from 4.14 to 4.16+ resolved the issue by prioritizing IP+PORT over INADDR_ANY lookups.
This article explains the Linux kernel scheduler's core concepts, walks through the initialization code of the 5.4 kernel (including run queues, scheduling classes, domains, and groups), and details how multi‑core and NUMA topologies are handled to achieve balanced CPU usage.
This article provides a comprehensive overview of Linux's core components—including the kernel, shell, virtual file system, various filesystem types, directory hierarchy, disk partition schemes, mounting procedures, and linking mechanisms—while illustrating key concepts with commands, code snippets, and diagrams for practical system administration.
This comprehensive guide walks through Linux memory management, explaining CPU memory access, virtual‑to‑physical address translation, page‑table initialization, zone organization, the buddy allocator, slab allocator, vmalloc, page‑fault handling, and CMA, providing code examples and diagrams to form a complete understanding.
The article surveys several unconventional Linux filesystems—OverlayFS for layered read‑only overlays, IncFS enabling incremental app loading, ZoneFS exposing zoned block device zones, LTFS bringing true file‑system semantics to magnetic tape, and StegFS hiding data steganographically—highlighting their unique designs and use cases.
This article explains Linux scheduling fundamentals, describing the task_struct fields, scheduling classes, runqueue organization, the scheduling workflow including flag setting and execution, and the details of the context_switch function that performs address‑space and register state switches.
This comprehensive guide walks you through selecting a secure Linux distribution, configuring kernel and sysctl parameters, applying boot‑time hardening, managing network and firewall rules, restricting root access, enabling MAC policies, sandboxing applications, and employing advanced memory and entropy techniques to dramatically improve system privacy and resilience against attacks.
This article explains the Linux PM QoS framework, detailing its background, system‑ and device‑level constraints, core data structures, key API functions, and a practical example of limiting CPU‑DMA latency for power‑efficient device operation.
This article provides a deep, step‑by‑step analysis of how Linux 3.10 processes a send() call—from user‑space socket handling through TCP, IP routing, queueing, driver DMA mapping, and both hard and soft interrupt handling—answering why CPU time appears in sy/si, why NET_RX softirqs dominate, and what memory copies occur during transmission.
This comprehensive guide explains how to dramatically improve Linux security and privacy by selecting hardened distributions, configuring kernel and boot parameters, applying sysctl tweaks, disabling unnecessary services, using MAC frameworks, sandboxing applications, hardening memory allocation, and following best‑practice system administration steps.
This guide explains why adhering to the Linux kernel coding style matters, introduces automatic tools such as checkpatch.pl, Lindent, and astyle for fixing style violations, and details the core conventions for indentation, line length, brace placement, naming, comments, macros, and other critical aspects of kernel C code.
After a week‑long delay, Linux Kernel 5.12 was officially released, introducing variable refresh‑rate support for Intel Xe GPUs, Radeon RX 6000 overclocking, Nintendo 64 mainline support, a PlayStation 5 DualSense driver, CXL 2.0 storage support, KFENCE, dynamic preemption, faster Clang linking, and numerous laptop‑related enhancements.
After a week-long delay, Linus Torvalds announced the official release of Linux kernel 5.12, highlighting support for Intel Xe GPU variable refresh rates, C language link‑time optimization (LTO), kernel fencing (KFENCE), and overclock profiles for AMD Radeon RX 6000 series, while noting it’s a modest update ahead of the larger 5.13.
Linux’s Virtual File System (VFS) acts as a glue layer between user space and various file systems, providing a unified interface and object model—including superblocks, inodes, file and dentry objects—and employs caching mechanisms like dcache to efficiently manage directory entries.
After a week-long series of experiments measuring TCP connections in various states—including ESTABLISH, client‑to‑server, server‑to‑client, and non‑ESTABLISH scenarios—the author quantifies per‑connection memory usage and shows how modern kernels reclaim buffers and reduce overhead, especially for TIME_WAIT.
This article breaks down Android's power‑button handling pipeline, detailing the hardware interrupt registration, kernel‑to‑user‑space event propagation, strategy‑based decision making, and the intricate wake‑up and sleep sequences that control screen illumination.
This article dissects Linux's synchronous blocking network I/O implementation, explaining how socket creation, recv handling, and soft‑interrupt processing each incur context‑switch overhead that makes BIO unsuitable for high‑concurrency server workloads.
This article explains why synchronous blocking network I/O (BIO) is a performance bottleneck in high‑concurrency Linux servers, detailing the kernel‑level steps of socket creation, the recv path, soft‑interrupt handling, and how processes are blocked and later awakened.
This article explains the Linux virtual file system (VFS) architecture, its role in abstracting concrete file systems, and details core kernel structures such as superblocks, inodes, dentries, file objects, and their relationships to processes, providing code examples and diagrams for clarity.
This comprehensive guide explores Linux's four main components—kernel, shell, filesystem, and applications—detailing kernel architecture, memory and process management, VFS, device drivers, networking, file types, directory structures, mounting, and practical commands for managing partitions and links.
This article explains the Linux I/O stack, detailing how data moves from user‑space buffers through libc and page cache to the disk, covering system calls, synchronization primitives, scheduler behavior, consistency, safety, and performance considerations.
This article explains the concept of per‑CPU variables in the Linux kernel, how they are defined with DEFINE_PER_CPU, linked into the .data..percpu section, initialized during boot, and accessed at runtime via the GS register and macro expansions such as this_cpu_read_stable.
This article provides a comprehensive, step‑by‑step walkthrough of how Linux handles system calls, covering the low‑level assembly entry point, register conventions, the sys_call_table registration process, struct pt_regs usage, and a practical write‑syscall example with a custom extension.
This article provides a detailed, step‑by‑step walkthrough of the Linux kernel’s packet‑receiving path, covering NIC DMA, hardware and soft interrupts, ksoftirqd threads, NAPI polling, protocol‑stack registration, IP/UDP processing, and the final recvfrom system call that delivers data to user space.
This article presents a seven‑day experiment measuring how much memory a TCP connection occupies in the kernel under various states such as ESTABLISH, data transfer, and TIME_WAIT, and summarizes the kernel's memory‑optimisation techniques for sockets.
The article explains how the Linux kernel discovers and calls module initialization functions like inet_init by using the fs_initcall macro, which creates static initcall variables placed in specially‑named sections that the linker groups and the kernel iterates at boot time.
This article explains how Linux 3.10 organizes memory using NUMA nodes, zones, the buddy system, and the SLAB allocator, providing commands, code examples, and visual diagrams to illustrate each layer of the kernel's efficient memory management.
This article explains the Linux kernel memory management hierarchy—including NUMA nodes, memory zones, the buddy system for free pages, and the SLAB allocator—providing command‑line examples, code snippets, and visual diagrams to illustrate how the kernel efficiently allocates and reclaims memory.
Teen developer Daniel Rodriguez repurposes a non‑functional iPhone 7 by jailbreaking it, building a custom Ubuntu 20.04 root filesystem, compiling a tailored kernel, and using projectsandcastle and PongoOS to boot Linux, effectively turning the device into a networked ARM64 server.
This article provides a comprehensive overview of Linux's core components—including the kernel, memory and process management, virtual file system, device drivers, network stack, shell variants, file types, directory hierarchy, partitioning, mounting, and essential command‑line tools—while illustrating each concept with diagrams and code examples.
This guide shows how to increase the number of concurrent TCP connections on a Linux server by adjusting kernel parameters, expanding file descriptor limits, and understanding the underlying socket structures and lookup mechanisms that govern connection handling.
This article explores Linux’s TCP socket implementation, showing how to adjust system limits, dissecting key kernel structures like sock_common, and walking through the tcp_v4_rcv processing path and inet lookup functions, ultimately revealing methods to scale client connections beyond the traditional 65 535 port limit.
A production Kubernetes cluster experienced intermittent network jitter caused by the IPVS estimation_timer soft‑interrupt, and the article details how BPF tracing, perf analysis, and a kpatch live‑patch were used to identify and eliminate the latency without rebooting the nodes.
This article explains the principles, use cases, and kernel implementation of Linux connection tracking (conntrack), covering its role in NAT, L4 load balancing, Netfilter hook mechanisms, key data structures, core functions, and performance considerations.
The article explains why a client can successfully write to a TCP socket after the server has closed its end, why the first write succeeds while the second fails, and how Linux kernel code and TCP state transitions cause this behavior.
This article explains the differences and purposes of Linux I/O flushing mechanisms—including fsync(), fdatasync(), sync(), the O_DIRECT and O_SYNC open flags, and the REQ_PREFLUSH and REQ_FUA bio request flags—illustrated with dd experiments, kernel flag tables, and practical commands for managing disk write caches.
This article walks through the complete Linux kernel path a network packet follows—from the NIC’s DMA and hardware interrupt, through soft‑interrupt handling, NAPI polling, protocol‑stack registration, IP and UDP processing, all the way to the user‑space recvfrom system call—revealing the many hidden steps that make packet reception possible.
Linux uses swapping to move rarely used memory pages to disk, alleviating memory pressure and reclaiming idle memory, but the performance impact of disk I/O can cause latency; this article explains the mechanisms, triggers, and kernel functions behind swapping, including direct reclaim, kswapd, and LRU lists.
This guide explains WireGuard's strict kernel requirements, shows how to upgrade kernels on various Linux distributions, provides detailed commands for installing WireGuard on older kernels, and introduces a one‑click script that automates configuration, firewall adjustments, and client management.
This article explains the fundamentals of Linux ftrace, details the event‑tracing mechanism and tracepoint macros, shows how to enable and filter events on ARM64 Android devices, and demonstrates a practical workflow for capturing low‑probability scheduling bugs in camera‑related processes.
An imaginative tale reveals how two covert agents exploit the Linux kernel’s DelayedACKLost counter via /proc/net/netstat, using it to infer TCP sequence numbers and perform a side‑channel hijack, while illustrating the underlying delayed ACK mechanism, related kernel functions, and the security implications of this hidden metric.
This article explains how to monitor and tune Linux network packet reception using tools such as ethtool, ifconfig, and procfs, covering RingBuffer inspection, hardware and soft interrupt analysis, multi‑queue configuration, interrupt coalescing, and GRO settings to improve throughput and reduce packet loss.
Linux 5.10 brings a slew of network upgrades—including bundled BPF programs, support for over 255 IPv4 multicast interfaces, MPTCP refinements, Intel IGB XDP support, new Wi‑Fi driver chips, up to 20% performance gains for Mellanox NICs, and a BPF helper that boosts TCP throughput from 10 Gbps to 15 Gbps.
This article explains the concepts of kernel space and user space in a 32‑bit OS, why they are separated, the distinction between kernel mode and user mode, how processes transition between them, and the overall Linux system structure.
A comprehensive guide walks through Linux fundamentals, covering the UNIX heritage, kernel structure, system calls, process and thread creation, inter‑process communication, memory management, file‑system design, I/O handling, scheduling algorithms, modules, and built‑in security mechanisms.
This article explains Linux process memory organization, detailing how task_struct and mm_struct describe virtual memory, the role of vm_area_struct for each segment, page table interactions, and the lazy allocation mechanism that maps physical memory only on page faults.
This comprehensive guide breaks down the four main parts of a Linux system—kernel, shell, filesystem and applications—detailing kernel subsystems such as memory and process management, shell variants, file types, directory hierarchy, partition handling, VFS, mounting procedures, link types and essential command‑line tools, while also touching on application bundles and kernel parameter tuning.
This article explains how a user‑level program becomes a Linux process, how the kernel views it through ELF loading, the role of the task_struct data structure, its key fields, task state transitions, and how the kernel stores the descriptor in memory.
The article explains that kernel code must copy user‑space buffers with copy_from_user rather than using memcpy, covering the necessity of copying, the built‑in access checks, page‑fault handling, security implications, and modern hardware safeguards like PAN.
This article provides a comprehensive, illustrated explanation of how Linux receives network packets—from hardware DMA and interrupt handling through soft‑interrupt processing, NAPI polling, protocol stack registration, and finally delivery to user‑space via recvfrom—detailing each kernel component and relevant source code.
This comprehensive guide explores Linux’s four core components—kernel, shell, filesystem, and applications—detailing kernel architecture, memory and process management, VFS, device drivers, network interfaces, shell types, file types, directory structures, mounting, and essential command-line tools for system administration.
This guide shows a quick user‑space technique to conceal a Linux process by overwriting its PID with an unused value using a short SystemTap script, includes the exact code, execution steps, detection method, and a brief explanation of why it works.
This comprehensive guide walks through Linux's core components—including the kernel, shell, and file system—explaining memory and process management, VFS architecture, partition types, mounting procedures, common commands, and optimization tips, all illustrated with diagrams and practical examples.
This article provides a comprehensive overview of Linux’s core architecture, detailing the kernel, shell, memory and process management, virtual file system, various file system types, directory structures, partitioning, mounting procedures, and link mechanisms, offering readers a solid foundation for mastering Linux systems.
This comprehensive guide explores Linux's core components—including the kernel, shell, memory and process management, file systems, device drivers, network interfaces, mounting mechanisms, and link types—providing clear explanations, diagrams, and command examples for anyone learning operating system fundamentals.
This article walks through the design and implementation of a tiny Linux filesystem called TinyFS, explaining the VFS layers, required POSIX interfaces, data structures, core kernel code, usage steps, current limitations, and a roadmap for extending it with proper superblocks, concurrency, and page‑cache integration.
