This guide explains the Linux kernel TCP parameters located under /proc/sys/net/ipv4/ and /proc/sys/net/core/, shows how to tune them with sysctl, and provides practical examples and recommended values for improving network performance and security.
The article explains a kernel‑space memory profiler that uses a compile‑time code‑tagging library and special linker sections to record allocation callers and byte counts with minimal CPU overhead, allowing the tool to be deployed in production.
This article provides a comprehensive overview of the Linux process scheduler, explaining why scheduling is needed, how it works, the various scheduling policies such as real‑time and CFS, the mechanisms for priority and load balancing, and the historical evolution of Linux schedulers with code examples.
This article explains the Linux kernel's four‑level page‑table mechanism, the performance impact of TLB misses, why using 2 MB HugePages improves address‑translation efficiency, and provides step‑by‑step instructions for reserving and allocating HugePages via boot parameters, sysfs, and mmap.
The article explains how the Earliest Eligible Virtual Deadline First (EEVDF) scheduler, introduced in Linux 6.6, replaces CFS by using virtual deadlines and a lag concept to achieve both fairness and interactivity, and walks through concrete formulas, parameter settings, and step‑by‑step scheduling examples.
This article provides a comprehensive analysis of the Linux kernel's task_struct data structure, detailing its members such as task IDs, parent‑child relationships, state flags, credentials, scheduling information, signal handling, memory and file management, kernel stack layout, and its role in process creation via system calls like fork.
This article explains how the Linux kernel implements heap memory management, covering the heap data structure, the mm_struct fields start_brk and brk, the brk/sbrk and malloc/free allocation methods, the brk and mmap system calls, and the internal glibc structures heap_info and malloc_state that track heap state.
This guide explains how to optimize Linux kernel parameters, increase file descriptor limits, and choose appropriate disk scheduling strategies to improve server performance, with practical examples for network tuning, Nginx configuration, and system resource adjustments.
This article provides a comprehensive overview of Linux process management, covering fundamental concepts such as tasks and states, the internal task_struct representation, process creation via fork/vfork/clone, execution with execve, lifecycle transitions, scheduling policies, copy‑on‑write optimization, resource limits, and practical tools for monitoring and controlling processes.
The article describes a kernel‑level hot‑key detection module for Redis that tracks per‑second access counts via an O(1) LRU queue, flags keys exceeding configurable thresholds, and provides real‑time subscription alerts and queryable logs, overcoming the latency and overhead limitations of existing detection methods.
This article explains how the SIGPIPE signal is generated in Linux, why it can cause Go‑Rust services to crash without a core dump, and how to prevent it by configuring the signal handler to ignore SIGPIPE.
In a candid interview at the Linux Foundation Open Source Summit, Linus Torvalds and Verizon open‑source lead Dirk Hohndel discuss the Linux kernel's release cadence, security patching, the delayed integration of Rust, and Torvalds' cautious view of AI's role in software development.
Linus Torvalds merged a kernel patch that modifies the 64‑bit copy_from_user() implementation to avoid the slow barrier_nospec() call, achieving a 2.6% performance improvement in the "will it scale" benchmark and will be included in the upcoming Linux 6.12 stable release.
This article explains the Linux kernel architecture, breaks it into three layers and five key subsystems—process scheduling, memory management, virtual file system, network interface, and inter‑process communication—detailing their responsibilities, inter‑dependencies, and providing concrete code examples and diagrams.
This article provides a comprehensive overview of Linux's task_struct, explaining how the kernel represents and manages processes and threads, detailing its internal fields, state handling, scheduling, credentials, memory layout, and special mechanisms such as hung‑task detection.
Linux founder Linus Torvalds confirmed that the kernel project has recently stripped more than ten maintainers linked to Russia, citing compliance requirements and U.S. sanctions, while the removed contributors' driver code remains in the source tree.
This article provides a comprehensive overview of how Linux kernel system calls are implemented on the x86-64 architecture, covering the conceptual differences from regular function calls, register conventions, initialization processes, syscall tables, and practical assembly examples such as write and getpid.
This article explains Linux swap fundamentals, detailing how the kernel uses swap partitions or files, the role of the swappiness parameter in balancing cache reclamation versus anonymous page swapping, the operation of kswapd, and the impact of memory watermarks on reclamation decisions.
The article explains how Linux manages memory page watermarks, when the allocator falls back to kswapd, and the exact conditions that trigger direct compaction via __alloc_pages_direct_compact, then walks through the core compaction functions—try_to_compact_pages, compact_zone_order, compact_zone, and the page‑migration helpers—illustrated with flow diagrams and real kernel code.
At the recent virtual eBPF summit, Isovalent CTO Thomas Graf revealed that Microsoft is developing a Windows version of eBPF, aiming for cross‑platform compatibility with Linux, while the IETF works on standardizing the eBPF ISA and verifier to ensure secure, portable kernel bytecode execution.
When a computer finishes loading a webpage and the user does nothing, the CPU appears idle, but the operating system runs a special idle process that repeatedly executes the halt instruction, managing power consumption and illustrating core concepts of processes, scheduling, and hardware‑software interaction.
In September 2024, TencentOS sent two kernel engineers to Vienna to attend the Linux Plumbers Conference and the Linux Kernel Developers' Netconf, where they presented cutting‑edge research on network diagnostics, SWAP allocation, and memory management, fostering collaboration with leading open‑source contributors.
This article walks through the Linux kernel mechanisms for creating and destroying processes, covering copy‑on‑write, the fork/vfork/clone system calls, the kernel_clone implementation in kernels 5.0 and 6.5, the copy_process workflow, and the steps the kernel takes to wake up a new task and clean up a terminated one.
At the Open Source Summit Europe, Linus Torvalds warned that the Linux kernel’s aging maintainers and a shrinking pool of interested developers threaten succession, stressing that future leaders must earn community trust through sustained contributions, while better mentorship, documentation, and outreach are needed to attract new talent.
This article explains why Linux kernel network packet loss occurs, covering causes such as UDP checksum errors, firewall misconfigurations, rp_filter settings, buffer overflows, and hardware faults, and provides detailed diagnostic steps and practical solutions to identify and resolve each issue in Linux environments.
This article provides a thorough overview of Linux kernel debugging techniques, covering pseudo‑filesystems such as procfs, sysfs, debugfs and relayfs, as well as essential tools like printk, ftrace, trace‑cmd, kprobe, systemtap, kgdb, kgtp, perf, and other modern tracers, helping developers diagnose and optimise kernel behavior.
An in‑depth post‑mortem of a recurring midnight kernel panic caused by a malformed sk_buff structure, detailing how vmcore analysis, packet inspection, and netfilter hook tracing pinpointed a third‑party module bug in Linux 5.10, and outlining remediation steps.
The article explains how Linux separates board‑level information from drivers using a bus‑device‑driver model, illustrating high cohesion and low coupling with concrete code examples, matching mechanisms, and the evolution toward device trees for scalable hardware abstraction.
The article examines the role of various locks in Linux kernel memory management, explains their APIs and sleeping constraints, presents detailed case studies of lock‑related performance patches—including per‑memcg LRU, mmap_lock IO‑fault path, SPF, PVL, fault‑around, unmap, and rmap lockless optimizations—and summarizes common strategies for reducing lock contention and improving scalability.
This article explains core operating system concepts—including its main functions, the distinction between user and kernel modes, process and thread management, and semaphore-based synchronization—providing clear definitions, code examples, and practical usage scenarios for developers.
This article provides a comprehensive guide on how to employ GDB for debugging programs that lack symbol information, covering basic commands, breakpoint techniques, core‑dump analysis, reverse debugging, and a practical example of integrating VSCode, GDB, and QEMU to debug an ARM64 Linux kernel.
This article demystifies the Linux free command’s “buffers” and “cached” fields by tracing their origins through /proc/meminfo, kernel source functions such as meminfo_proc_show, nr_blockdev_pages, and page‑cache mechanisms, and demonstrates the differences with practical experiments.
A newly disclosed Linux kernel vulnerability called "indler"—a 0‑day memory‑corruption bug hidden since 2012—was uncovered by security researcher Zhang Yinkui, who detailed its discovery via a random kernel oops, KASAN detection, and its potential for massive remote code execution across billions of devices.
This guide walks you through obtaining the Linux kernel source, configuring key options, compiling and installing the kernel, tuning sysctl parameters, and continuously monitoring system metrics to achieve higher performance, stability, and security in high‑load environments.
This article explains the principles of virtual memory, the data structures and functions used in uCore to manage page faults, and how the operating system handles demand paging, page swapping, and invalid accesses through detailed code examples and workflow descriptions.
This article provides a comprehensive overview of the Linux /proc virtual filesystem, detailing how to mount it, the structure of its directories and files such as /proc/pid, /proc/self, and various system information files, and includes practical command examples and security considerations.
This article walks through Android Binder IPC on Android 14 and Linux 6.1, detailing client‑side service registration and lookup, the kernel driver’s handling of parcels, reference management, and how ServiceManager maps names to IBinder objects, culminating in a diagram of the full native‑to‑kernel transaction flow.
This guide explains how to fine‑tune Linux kernel settings—including sysctl network parameters, shared memory limits, local port ranges, and disk scheduler options—using configuration files and command‑line tools to improve system stability and throughput.
This article details the investigation of a "directory not empty" failure when using Go's os.RemoveAll on a self‑built FUSE‑based distributed filesystem, describing the kernel readdir offset issue, the debugging steps taken, and the final fix applied.
This article walks through a real Linux kernel hard lockup case, explaining what hard lockup is, analyzing stack traces and register values, identifying a spinlock contention on a per‑CPU runqueue, and showing how an inappropriate GFP flag caused interrupts to be enabled at the wrong time, leading to a deadlock and the eventual fix.
This article introduces eBPF, explains its zero‑intrusion observability advantages, describes its architecture and runtime workflow, outlines development prerequisites and compilation steps, and provides concrete Go‑based examples for tracing bash commands and measuring TCP connection latency.
This guide compiles practical Nginx performance‑tuning directives, FastCGI settings, Linux kernel parameter adjustments, security hardening tips, and monitoring configurations, providing concrete examples and command‑line snippets to help sysadmins and developers optimize high‑concurrency web services.
This article explains the design and implementation of file readahead in the Linux 3.12 kernel, using sequential, random, and multithreaded read scenarios to show how the kernel initializes readahead windows, triggers synchronous and asynchronous prefetches, and updates the page cache.
The article provides a comprehensive guide to the Linux /proc virtual filesystem, explaining its purpose, how to mount it, and detailing the most important files and directories such as /proc/pid, /proc/self, security attributes, memory maps, and network information, along with practical commands for inspection.
This article explains the Linux /proc virtual filesystem, detailing its purpose as a kernel interface, how to mount it, and describing the most important files and directories—such as /proc/[pid], /proc/self, /proc/net, and security‑related entries—along with example commands for inspecting process information.
The article provides a comprehensive guide to Linux’s /proc virtual filesystem, detailing its purpose, mounting methods, key directories such as /proc/pid, /proc/self, and numerous files that expose process, thread, memory, and kernel information, along with practical command examples.
Linux kernel 6.9’s first stable release brings Rust support on AArch64, expanded hardware drivers, performance optimizations, filesystem enhancements, BPF and perf tool upgrades, as well as network and security improvements, while previewing the upcoming 6.10 development cycle.
Linux’s “watchdog: BUG: soft lockup – CPU#1 stuck” warning indicates a CPU soft lockup, caused by driver bugs, hardware faults, or kernel issues, and can be resolved by updating software, monitoring hardware, analyzing logs, and implementing preventive performance and hardware checks.
This comprehensive guide explains Linux memory fundamentals, address space layout, fragmentation, the buddy and slab allocators, kernel and user‑mode memory pools, DMA handling, common programming pitfalls, and practical tools for monitoring memory usage.
This comprehensive guide explores Linux memory architecture, address spaces, allocation strategies like the buddy and slab allocators, user‑ and kernel‑level memory management, DMA, and practical tips to avoid common memory bugs and performance issues.
This article provides a comprehensive guide to Linux memory management, covering memory fundamentals, address spaces, MMU translation, segmentation and paging, the buddy and slab allocation algorithms, kernel and user memory pools, typical usage scenarios, common bugs, and practical tools for monitoring and debugging memory usage.
This article lists a comprehensive series of 46 video lectures covering essential Linux kernel concepts such as scheduling, memory management, synchronization, file systems, networking, and device drivers, providing a valuable resource for embedded and systems programmers.
This guide lists 44 essential Linux kernel and sysctl parameters, providing their default values and recommended settings to improve memory management, networking, file handling, and overall system stability for production environments and reliability.
This comprehensive Q&A explains Linux system composition, kernel placement, core subsystems, address translation, paging structures, process concepts, scheduling algorithms, interrupt handling, system calls, synchronization, deadlock avoidance, and the virtual file system, providing a solid foundation for operating‑system fundamentals.
This article explains the architecture and implementation of the virtio/vhost device model, details how QEMU creates and initializes virtio‑net‑pci devices, describes the vhost‑user communication protocol and its integration with DPDK and the Linux vhost‑net kernel driver, and provides practical command‑line examples and code snippets.
This article explains the fundamentals of TCP RST packets, distinguishes active and passive resets, outlines common kernel scenarios that generate them, and provides practical debugging methods using tcpdump, bpftrace, and source‑code analysis to resolve real‑world network incidents.
This article explains the concept of system calls, how they provide a privileged interface between user programs and the kernel, distinguishes them from APIs and library functions, and describes their role in Linux operating‑system architecture and application development.
This article introduces IPVS, the Linux kernel‑level load balancer, explains its scheduling algorithms, forwarding modes (DR, NAT, IP tunneling), and provides step‑by‑step commands to configure virtual services, real servers, and routing in a virtualized environment.
Linus Torvalds sharply rebuked a Google contributor’s inode proposal on the Linux kernel mailing list, calling the 1970s‑era inode concept an outdated relic that need not serve as a unique file‑system identifier, warning it adds unnecessary complexity and dismissing the submitted patch as garbage code.
Linus Torvalds blasted a Google contributor’s proposal to make all file and directory inodes identical, calling the idea outdated, labeling the pull request as garbage, and urging that the inode concept be abandoned in favor of modern file‑system designs that no longer rely on unique identifiers.
Linus Torvalds unleashed a rare, scathing rebuke on the Linux kernel mailing list, denouncing Google contributor Steven Rostedt’s inode‑related patch as “garbage code” and arguing that the legacy practice of treating inodes as mandatory unique identifiers is outdated and should be abandoned.
The article investigates why BPF LSM programs fail to load on aarch64 kernels, uses ftrace‑based tools such as bpftrace and trace‑cmd to trace kernel execution, discovers missing arch_prepare_bpf_trampoline support in 5.15 and 6.1, and shows that a patch merged into the mainline kernel restores functionality for upcoming releases.
This article analyzes the XFS filesystem implementation in the Linux kernel, covering its on‑disk layout, superblock and allocation‑group structures, inode and free‑space B+ trees, operation sets (iops, fops, aops), file creation, write and read paths, logging, block layer interactions, and useful XFS utilities.
This article explains the Linux kernel boot sequence on ARM platforms, covering how the compressed kernel is decompressed, the role of the stext entry point, the preparation steps performed by __switch_data, and the detailed initialization performed by start_kernel and its key sub‑functions.
This article explains the Linux kernel boot sequence, covering the decompression of a compressed kernel, the early startup code in head.S, the preparation steps performed by U-Boot, and the detailed initialization phases—including architecture setup, memory management, process creation, and the start_kernel routine.
When a computer has no active user tasks, the CPU appears idle but actually runs a special system idle process that repeatedly executes the privileged halt instruction, allowing the processor to enter low‑power states while the operating system manages process queues and scheduling.
This article explains how the Linux kernel allocates dynamic memory, distinguishes kernel and user‑space allocation strategies, describes the mm_struct layout of a process address space, and shows how pages and page tables translate virtual addresses to physical memory.
This article explains how Linux processes can share large data efficiently by creating a memory file with memfd_create, mapping it with mmap, and transferring the file descriptor over a Unix Domain Socket, while detailing the kernel mechanisms that enable true cross‑process memory sharing.
This article explains the fundamentals of memory‑mapped files in Linux, covering the mmap/munmap interfaces, mapping types, protection flags, error handling, virtual‑memory structures, kernel implementation details, driver examples, and practical use‑cases such as shared memory and high‑performance I/O.
This article explains Linux process scheduling, the difference between TASK_RUNNING, TASK_INTERRUPTIBLE, and TASK_UNINTERRUPTIBLE states, shows code examples for putting a process to sleep and waking it, analyzes the invalid wakeup race condition, and presents kernel patterns that safely avoid such issues.
This article provides a comprehensive overview of Linux processes—from their definition and lifecycle to creation, scheduling strategies such as FCFS, round‑robin, EDF, and RMS, as well as various inter‑process communication mechanisms like pipes, sockets, shared memory, semaphores, and the kernel implementation of fork and context switching.
The article examines the scalability limitations of the Linux kernel TCP/IP stack, comparing its packet‑processing and connection‑setup performance with user‑space stacks such as mTCP and F‑Stack, explains how hash‑table locking and spin‑lock contention cause poor CPS scaling, and argues why user‑space implementations often achieve higher throughput despite their own trade‑offs.
This article explains how Linux processes transition between running and sleeping states, the difference between interruptible and uninterruptible sleep, common pitfalls such as invalid wakeups, and best‑practice kernel patterns to avoid race conditions when putting a process to sleep.
This technical report details the background, hardware configuration, database setup, tuning results, and step‑by‑step optimization procedures—including BIOS, OS, network, container NUMA binding, MySQL CRC32 patching, and Go PGO tuning—performed to improve JED performance on ARM compared with Intel.
This article explains the Linux kernel's mmap implementation, covering how virtual memory is allocated, the role of get_unmapped_area, mmap_region, overcommit policies, VMA merging, and the underlying data structures such as mm_struct and vm_area_struct.
At the European Open Source Summit, Linux kernel maintainer Jonathan Corbet announced that long‑term support will drop from six to two years due to low usage, lack of support, and maintainer burnout, a shift that could heavily impact Android and other embedded devices.
This article provides an in‑depth exploration of the Linux mmap system call, covering its role in virtual memory management, page table structures, various mapping types (anonymous, file‑backed, shared, private), flag options, and advanced concepts such as huge pages and transparent huge pages, with kernel‑level diagrams and code examples.
Linus Torvalds criticized the ambiguous 'GenPD' naming in a recent ARM SoC driver update PR for Linux 6.6, demanding the subsystem be renamed before merging after finding no documentation for the generic power‑management domain provider.
This article explains the Linux virtual file system (VFS) architecture, detailing the key data structures such as superblock, inode, dentry, and file objects, and walks through the step‑by‑step process of the open() system call from user space down to kernel internals.
The article walks through the complete eBPF injection workflow—opening a skeleton, loading and JIT‑compiling the program with bpf_object__load_skeleton, attaching it to a kernel kprobe via perf_event_open_probe and bpf_link_create, and finally triggering the probe so the JIT‑compiled eBPF code runs inside the kernel.
This article explains the fundamentals of Linux interrupt handling, covering the concepts of hardware and software interrupts, the IRQ processing flow, maskable versus non‑maskable interrupts, and the three deferred execution mechanisms—softirq, tasklet, and workqueue—along with code examples and practical considerations.
This article explains the concept of network packet loss, walks through the sending and receiving mechanisms of Ethernet frames, and provides a comprehensive, layer‑by‑layer checklist—including hardware NIC, driver, kernel, IP, TCP/UDP, and application‑level diagnostics—plus concrete Linux commands and configuration tweaks to locate and fix the root cause.
Linus Torvalds has publicly criticized AMD’s firmware‑based TPM random number generator for causing system stalls on Linux, urging the community to disable the fTPM hwrng until reliable fixes are delivered, highlighting broader security and firmware concerns.
Debian 12.1, the latest point release of the long‑standing stable Linux distribution, brings a host of security patches, bug fixes, and a major kernel upgrade from 5.10 to 6.1 LTS, while also updating many packages and improving hardware support across architectures.
Linux 6.4 has been officially released, featuring the removal of SELinux runtime disabling, enhancements to F2FS and Btrfs filesystems, a batch of new Rust code, integration of Intel LAM after criticism, performance optimizations for LoongArch, early Apple M2 support, Wi‑Fi 7, and AMD autonomous boot, while the merge window for 6.5 is now open.
This article explains Linux process creation and termination, covering kernel functions like kernel_thread, kthread_create, kthread_run, the central _do_fork implementation, and user‑space interfaces such as fork, vfork, and pthread_create, with code snippets and diagrams.
This article explains the architecture and implementation of the Linux kernel kmalloc memory pool, detailing slab cache creation, size selection rules, cache initialization, allocation and free paths, and how different memory zones are handled, with code examples and diagrams.
This article explains how the Linux kernel supplements its buddy system with the slab allocator to efficiently manage tiny memory blocks, covering slab’s design, memory layout, red‑zone protection, poisoning, per‑CPU caches, NUMA node warehouses, allocation fast‑paths, slow‑paths, and release strategies.
This article reviews the fundamentals of eBPF, explains its architecture and tracing mechanisms such as USDT, uprobes, and TC hooks, provides practical code examples, discusses security aspects, and lists notable open‑source projects that leverage eBPF for performance and observability.
Linus Torvalds announced the Linux 6.4-rc6 kernel, highlighting extensive XFS filesystem fixes, numerous driver updates—including GPU and network drivers—architectural patches for arm64, and a projected stable release around June 25, with a possible delay to July 2 if issues arise.
This article explains the step‑by‑step process Linux uses to receive and transmit network packets, covering the initialization of the network subsystem, the role of the ring buffer, interrupt handling, and the layered processing through the TCP/IP stack from the NIC up to the application.
This article explains Linux process states, how the scheduler puts a running task to sleep with TASK_INTERRUPTIBLE or TASK_UNINTERRUPTIBLE, how wake_up_process() restores TASK_RUNNING, why invalid wakeups occur due to race conditions, and the kernel techniques used to prevent them.
This comprehensive guide explains Linux memory management, covering physical and virtual memory concepts, allocation and release methods, related kernel functions, process switching interactions, performance tuning, leak detection, fragmentation handling, and real‑world application scenarios for servers, embedded systems, and driver development.
This article provides a comprehensive overview of the Linux kernel, explaining its core components, memory and process management, device drivers, system calls, and security, while detailing essential commands such as uname, lsmod, modinfo, modprobe, depmod, insmod, rmmod, sysctl, and guiding readers through kernel compilation and configuration using /proc and /sys.
This article walks through the Linux kernel's slab cache memory‑freeing path, explaining the kmem_cache_free API, validation steps, fast‑path and slow‑path reclamation, CPU‑local and NUMA‑node handling, and the final destruction of slab caches with detailed code examples.
This article explains Linux process states, how the scheduler puts processes to sleep and wakes them, describes the problem of invalid wake‑ups caused by race conditions, and provides kernel‑level coding patterns to prevent such issues while illustrating with concrete code examples.
The Linux 6.2 kernel series has been marked end‑of‑life on kernel.org, ending security patches and bug fixes, and users are urged to migrate promptly to the newer 6.3 series which brings several new features and will itself be supported only until mid‑2024.
This article explains the concepts and mechanisms behind Linux kernel tracing tools—including ftrace, perf, kprobes, uprobes, tracepoints, ftrace, perf events, and eBPF—showing how probes are injected, how trace data is collected, and which technology to choose for different debugging and performance scenarios.
This article explains the various Linux kernel synchronization mechanisms—including inter‑process communication, semaphores, mutexes, message queues, shared memory, and thread pools—detailing how they work, when to use them, and their role in ensuring coordinated execution within the kernel.
This guide explains why dual-machine debugging is needed, outlines the two main scenarios (virtual machine and physical machine), and provides step‑by‑step instructions for configuring VirtualKD as well as network‑based kernel debugging on Windows systems, including common test cases and useful commands.
