0 views collected around this technical thread.
This article explains Linux inode table structure, how commands like ls, stat, cp, mv, and rm interact with inodes, compares hard and soft links, outlines common system log files and their formats, and demonstrates centralizing logs on a rsyslog server.
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 walks through the step‑by‑step design of a simple file system on a 1 TB disk, introducing logical blocks, block bitmaps, inode structures, directory handling, indirect indexing, superblocks, and hierarchical file organization, while comparing the design to the classic ext2 filesystem.
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.
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 how Linux file systems represent file size versus actual disk usage, demonstrates the difference between Size and Blocks using du and stat, describes inode and multi‑level block indexing, and shows why copying a sparse 100 GB file with cp finishes in a fraction of a second.
The article explains why copying a seemingly 100 GB file with the cp command finishes instantly by analyzing file size versus allocated blocks, sparse file concepts, inode structures, direct and indirect block indexing, and how Linux file systems manage storage space efficiently.
The article explains why a 100 GB file can be copied in under a second by examining the difference between logical file size and physical block usage, demonstrating sparse file behavior, inode structure, direct and indirect block indexing, and how these mechanisms affect copy performance on Linux.
This article explains why the Linux cp command appears to copy a 100 GB file in less than a second by exploring sparse files, the distinction between file size and allocated blocks, inode structure, multi‑level block indexing, and how these concepts enable fast copying of seemingly huge files.
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.
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.
The article explains how a Linux file can appear to be 100 GB yet copy in under a second because the file system uses inodes, direct and indirect block pointers, and sparse allocation, separating logical size from actual physical storage.
The article explains why the Linux cp command appears to copy a 100 GB file in less than a second by exploring sparse files, the difference between logical file size and physical block allocation, and how inode direct and indirect indexing enable efficient storage and fast copying.
The article explains how Linux file systems use inodes and multi‑level block indexing to separate a file's logical size from its physical storage, illustrating why copying a seemingly huge file with the cp command can complete instantly when the file is sparse.
An unexpected fast copy of a 100 GB file using the cp command reveals the concept of sparse files, where the logical size differs from physical disk usage, and explains how file systems employ inodes, block allocation, and multi‑level indexing to manage storage efficiently.
The article details a step‑by‑step investigation of a MySQL server that ran out of memory due to massive slab cache consumption by inode and dentry objects, showing how Linux commands, scripts, and cache‑dropping techniques resolved the issue and revealed the root cause of excessive partition tables.
This article explains how the ext4 file system organizes data using inodes, direct and indirect blocks, extents, and directory indexing, detailing the structures, code definitions, and performance implications for both small and large files.
This article explains the physical and logical operation of mechanical hard drives and solid‑state drives, details the Ext4 filesystem structures such as superblocks, inodes, block groups, flexible and meta block groups, and outlines allocation strategies and link types.