1 views collected around this technical thread.
Linux kernel I/O mechanisms, from basic file operations and descriptors to advanced models like blocking, non‑blocking, multiplexed, signal‑driven, and asynchronous I/O, are explained in depth, covering their structures, system calls, caching strategies, and performance optimizations such as io_uring.
This article explains the role of the interrupt system in ARM‑based Linux platforms, covering hardware modes, vector tables, exception handling, GIC architecture, and kernel integration, and provides detailed code examples and optimization techniques for developers working on embedded and high‑performance systems.
This article explains Linux's memory reclamation mechanisms, covering the role of memory as the system's bloodstream, the three reclamation paths (fast, direct, kswapd), zone watermarks, page cache structures, reverse mapping, and how swap and compression are used to keep the system stable under memory pressure.
This comprehensive guide explains what Linux kernel Oops errors are, why they occur, and provides step‑by‑step debugging techniques—including environment setup, kernel configuration, printk usage, BUG macros, GDB, objdump, and memory‑checking tools—to help developers quickly locate and fix Oops issues in custom kernel modules.
This article explains the Linux Completely Fair Scheduler (CFS), covering its design goals, core concepts such as virtual runtime, weight, red‑black tree management, load‑balancing mechanisms, scheduling policies, and answers common questions about its operation and kernel code.
This article provides a comprehensive overview of Linux memory management, detailing the roles and mechanisms of the early boot memory allocator, the memblock subsystem, the buddy allocator for physical pages, and the slab allocator for small objects, including their data structures, algorithms, and practical usage scenarios.
This article explains how vhost/virtio solves virtual device communication bottlenecks, walks through a hand‑written implementation with shared memory and ring buffers, and details QEMU's backend driver creation, device realization, and the vhost‑user/vhost‑net interfaces that enable high‑performance virtual networking.
Netlink is a Linux‑specific inter‑process communication mechanism that provides asynchronous, full‑duplex, and multicast communication between user space and kernel space, offering advantages over traditional IPC methods and serving a wide range of networking, monitoring, and system‑management scenarios.
This article explains the ZRAM technology in Linux, covering its principles, configuration steps, kernel integration, performance optimizations, and practical use cases for improving memory utilization on embedded devices, Android, and legacy PCs.
This article explains how Linux manages memory through page reclamation, detailing the role of LRU algorithms, page classification, reverse mapping, direct and asynchronous reclaim paths, and the OOM killer, while providing code examples and practical tuning advice.
This article explains the Linux kernel reverse‑mapping (RMAP) mechanism, covering its historical background, core concepts, key data structures such as anon_vma and anon_vma_chain, and the detailed workflow for page creation, fork handling, and page reclaim or migration, with full code examples.
This article explains how the Linux kernel ensures safe concurrent access to shared resources through various synchronization mechanisms such as atomic operations, spinlocks, mutexes, read‑write locks, and semaphores, illustrating their concepts, APIs, and practical usage with code examples.
This article provides a comprehensive overview of the Linux kernel's task_struct structure, detailing its key fields, process and thread identification, state definitions, memory and credential handling, kernel stack layout, and includes a practical kernel module example for iterating over all processes.
Linux does not expose all physical memory to users; this article explains why the kernel reserves memory, detailing the early memblock allocator, crash kernel reservations, page structure overhead, and the handoff to the buddy system, illustrating how these mechanisms consume several hundred megabytes of RAM.
This article explains how Linux-like operating systems use virtual memory and the MMU to map virtual addresses to physical memory, describes the data structures (vma_struct and mm_struct) used by uCore, details the page‑fault handling flow, classifies fault types, and shows how these mechanisms affect system performance.
This article explains the Linux kernel buddy memory allocation algorithm, covering its basic principles, allocation and reclamation processes, key data structures, initialization steps, code examples, advantages and drawbacks, as well as its applications and evolution across kernel versions.
This article explains what Linux kernel Oops messages are, distinguishes between BUG, Oops, and panic, outlines common causes, preparation steps, debugging tools, kernel configuration options, and provides a detailed case study with analysis and solutions for kernel Oops troubleshooting.
This article explains how Linux’s real‑time scheduler works, covering the underlying concepts, key kernel data structures such as rt_rq and rt_prio_array, the SCHED_FIFO and SCHED_RR policies, practical code examples, configuration APIs, and optimization tips for industrial and multimedia applications.
This article explains the core principles of I/O read/write operations, detailing the data preparation and copying stages, the roles of kernel and user buffers, synchronization models, and performance optimizations such as double buffering, circular buffers, zero‑copy, read‑ahead, and delayed write.
This article provides a comprehensive, step‑by‑step explanation of how Linux receives network packets—from hardware DMA and interrupt handling through soft‑interrupt processing, kernel initialization, driver registration, and protocol‑stack traversal—culminating in delivery to the application layer via sockets.