0 views collected around this technical thread.
This article explains the design of Linux file systems, the role of inodes, data blocks, superblocks, and the Virtual File System layer that provides a unified interface for diverse storage back‑ends, detailing core structures, registration, mounting, and file operation workflows.
This article explains the architecture, components, and operational flow of a CSI driver using NFS as a concrete example, covering CSI fundamentals, sidecar containers, dynamic volume provisioning, pod creation, and the role of the Linux VFS in exposing remote storage to applications.
This article provides a comprehensive overview of Linux kernel I/O mechanisms, including file system interfaces, blocking and non‑blocking I/O, asynchronous models, multiplexing with select/epoll, EXT file‑system structures, VFS abstraction, consistency and journaling, as well as the complete block I/O path, scheduling algorithms, and debugging tools.
This article explains how Linux handles I/O operations, covering the virtual file system, inode and dentry structures, superblock layout, ZFS features, disk types, the generic block layer, I/O scheduling strategies, and key performance metrics for storage.
This article explains the Linux file I/O stack by outlining the path from user space through system calls to the kernel layers—VFS, filesystem, block layer, and SCSI—detailing each layer's role, page cache mechanisms, writeback processes, and direct I/O implementations with code examples.
This article explains the Linux file I/O stack by outlining its clear route from user space to hardware, detailing the roles of VFS, the filesystem, the block layer, and the SCSI driver, and then dives into page cache mechanisms and code paths for both buffered and direct I/O.
Even when the `df` command shows a full disk, hidden deleted files held open by processes can consume space, and understanding this requires diving into Linux’s virtual file system architecture, including superblocks, inodes, file and dentry objects, as well as link types and file‑process interactions.
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.
The guide explains Linux’s unified VFS architecture, detailing how inodes and dentries map files to disk regions, describes superblock and data block layout, outlines ZFS’s pool, copy‑on‑write and ARC caching, covers block device types, I/O scheduling queues, and key performance metrics.
This article explains how a seemingly simple read‑of‑one‑byte in user code triggers a complex Linux I/O stack involving the I/O engine, system calls, VFS, page cache, file system implementations, generic block layer and I/O scheduler, and clarifies when actual disk I/O occurs and its granularity.
The article thoroughly explains Linux kernel file cache, detailing how read() and write() operations traverse VFS to the block layer, the adaptive read‑ahead algorithm that pre‑loads sequential pages, the internal functions such as generic_file_buffered_read and ondemand_readahead, and outlines write handling and future topics on mmap and cache reclamation.
The article explains why a Linux system may report a full disk even after deleting files, detailing how open file handles keep space occupied, and walks through the virtual file system architecture—including superblocks, inodes, file and dentry objects—while demonstrating diagnostic commands like df, du, lsof, and illustrating link types and file‑process interactions.
This article explains how a simple read of a single byte in user space triggers a complex Linux I/O stack involving the read system call, VFS, page cache, generic block layer, and I/O scheduler, and clarifies when actual disk I/O occurs and how many bytes are transferred.
This article explains the layered architecture of Linux file systems, how generic API calls like read operate across different storage media, demonstrates creating and mounting loop‑back file systems with dd, losetup, mke2fs and mount commands, and details the core VFS structures such as superblock, inode, dentry and buffer cache.
This article provides a step‑by‑step tutorial on creating IntelliJ IDEA plugins, covering environment preparation, project creation, defining actions, updating plugin.xml, handling UI threads, launching background tasks, using ProgressManager, working with the Virtual File System and PSI, and leveraging the platform's UI components.
This article walks readers through the complete process of creating an IntelliJ IDEA plugin—from installing the SDK and setting up a project, to defining actions, handling UI threads, using background tasks, and exploring core concepts such as VFS and PSI—providing practical code examples and references for further learning.
This article explains what happens inside the Linux kernel when the rm command deletes a file on an ext4 filesystem, analyzes the relevant VFS and ext4 source code, and demonstrates how large‑file deletions can degrade I/O performance of other applications.
This article explains Linux cgroups—its subsystems, hierarchical structure, kernel implementation via VFS, mounting and configuration methods, and practical examples—showing how they provide fine‑grained resource control for processes and containers.