Tagged articles
Inode
84 articles · Page 1 of 1
A comprehensive guide to diagnosing and resolving Linux disk space alerts, covering block vs inode exhaustion, deleted-but-open files, log rotation, filesystem reserved space, read-only recovery, and safe cleanup practices with command examples and monitoring strategies.
FilesystemInodeLinux
0 likes · 117 min read

This article explains Linux system architecture covering kernel components (memory, process, device, network management), virtual file system (VFS), disk partitioning, mounting, inode/data block storage, hard vs soft links, and kernel parameter tuning via /proc.
Disk PartitioningHard LinksInode
0 likes · 39 min read

The article explains how a file system works—from physical disks to logical structures—using analogies like warehouses, detailing superblocks, inodes, data blocks, tree hierarchies, common file systems, Windows C‑drive growth, Linux ext4 features, permission models, and the role of the virtual file system.
EXT4InodeLinux
0 likes · 8 min read

This article explains why disk‑full issues cripple Linux servers, outlines the concepts of filesystem, LVM and inode space, and provides a step‑by‑step, layered method using df, du, find, lsof and logrotate to locate and safely free space, handle deleted‑but‑open files, clean logs, manage databases, temporary caches, Docker resources, and LVM volumes, and finally set up monitoring and preventive measures.
InodeLVMLinux
0 likes · 30 min read

This article provides a step‑by‑step, command‑driven methodology for identifying the five root causes of full disk space on Linux systems—block exhaustion, inode depletion, deleted‑but‑still‑held files, reserved space, and filesystem corruption—and offers concrete remediation techniques, automation scripts, and best‑practice recommendations.
InodeLVMLinux
0 likes · 55 min read

This article explains the core philosophy of Linux’s “everything is a file” design, walks through the kernel’s VFS layer, inode, dentry, superblock, logical blocks, and specific file systems, and provides hands‑on examples—including procfs initialization and read/write code—to help readers master Linux kernel file system internals.
InodeLinuxVFS
0 likes · 45 min read

The article explains Linux's core storage components—inode, dentry, superblock, and logical blocks—how the Virtual File System abstracts different file systems, the classification of file systems and I/O types, disk technologies, the block layer, I/O schedulers, and practical performance metrics and monitoring tools.
I/O schedulerInodeLinux
0 likes · 20 min read

This comprehensive guide explores the Linux kernel file system architecture, covering fundamental concepts such as inodes, dentries, superblocks, logical blocks, the VFS layer, common on‑disk filesystems, mounting procedures, and a deep dive into the proc virtual filesystem with code examples and practical usage tips.
InodeVFSfile-system
0 likes · 39 min read


ITPUBJan 13, 2026 · Fundamentals
This article walks readers through Linux file‑system fundamentals, explains the role of the Virtual File System (VFS), dives deep into ext2 structures such as superblocks, group descriptors, block and inode bitmaps, and provides complete C code for reading file contents directly by inode number.
Ext2InodeLinux
0 likes · 29 min read

This article guides readers through Linux file system fundamentals, explaining the role of the virtual file system (VFS), detailed structures of the ext2 superblock, group descriptors, block and inode bitmaps, and provides C code examples for extracting and reading file data directly via inode numbers.
Disk LayoutExt2Inode
0 likes · 27 min read

The article explains how inode exhaustion on Linux filesystems can cause "No space left on device" errors despite available disk space, details inode structure and allocation, provides step‑by‑step diagnostics, monitoring scripts, best‑practice recommendations, and recovery procedures to prevent and resolve inode‑related issues.
FilesystemInodeLinux
0 likes · 28 min read

This comprehensive guide walks you through Linux file system selection, inode and block allocation, formatting, mounting optimizations, ACL fine‑grained permissions, quota management, snapshot strategies, monitoring, performance tuning, capacity planning, security hardening, and troubleshooting for production environments.
ACLInodeLinux
0 likes · 37 min read

This article explores the evolution, design, and inner workings of the ext4 extent mechanism in Linux, detailing how it replaces traditional block mapping, improves storage efficiency, reduces fragmentation, and accelerates file I/O through compact data structures and B+‑tree indexing.
B+TreeEXT4Extent
0 likes · 18 min read

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.
InodeLinuxfile-system
0 likes · 9 min read

This guide explains Linux filesystem fundamentals—including inode structure, block allocation, hard and soft links, methods for recovering deleted EXT and XFS files, and practical techniques for analyzing system and application log files using common commands and tools.
Inodefile recoverylog analysis
0 likes · 12 min read

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.
InodeLinuxVFS
0 likes · 51 min read

This guide explains how Linux stores files using inodes, data blocks, and directory entries, details file metadata, outlines the creation and deletion processes, and compares hard and soft links with practical command examples and common pitfalls.
Hard LinkInodeLinux
0 likes · 6 min read

This article explains the Linux inode structure, how common commands like cp, rm, and mv interact with inodes, the differences between hard and soft links, and provides a detailed overview of system and user log files, log levels, and configuring a centralized rsyslog server.
InodeLinuxcommand-line
0 likes · 9 min read

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.
BitmapExt2Inode
0 likes · 10 min read

This guide explains Linux's unified file concept, the hierarchical directory layout, the role of inodes in mapping logical to physical storage, and the differences between hard and soft links, providing clear examples and visual diagrams for each topic.
FilesystemHard LinkInode
0 likes · 6 min read

This article introduces Linux's file system concepts, covering the unified view of resources as files, the hierarchical directory layout, the role of inodes in mapping logical to physical storage, and the differences between hard and soft links.
Hard LinkInodeLinux
0 likes · 6 min read

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.
InodeLinuxfile-system
0 likes · 2 min read


21CTOFeb 4, 2024 · Fundamentals
In the Linux 6.8‑rc2 release, Linus Torvalds sharply criticized the continued focus on inode numbers, arguing that the inode concept is outdated, while also highlighting new kernel bugs and urging the community to intensify testing and collaboration for a more stable release.
File SystemsInodeopen-source
0 likes · 7 min read

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.
InodeLinuxOpenSource
0 likes · 3 min read

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.
InodeLinuxOpenSource
0 likes · 2 min read

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.
FilesystemInodeStorage
0 likes · 12 min read

The article explains why a Linux server can run out of inodes despite having plenty of free disk space, demonstrates how creating an ext4 filesystem with the -T small option dramatically increases inode count, and discusses the performance trade‑offs and quick fixes for inode exhaustion.
EXT4FilesystemInode
0 likes · 6 min read

This article explains the core principles of Linux file systems, detailing how ext4 organizes data with blocks and inodes, uses indexing, extents, directory storage, bitmap management, meta block groups, and caching mechanisms, including buffered and direct I/O paths.
EXT4InodeLinux
0 likes · 19 min read

The article explains Linux’s Virtual File System (VFS) as an interface layer that treats all objects as files, illustrates the concept with Java‑style interface examples, then details the underlying C structures—file, file_operations, dentry, inode—and shows how the kernel links them to enable diverse file systems.
C++DentryInode
0 likes · 10 min read

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.
InodeLinuxblock indexing
0 likes · 12 min read

This article investigates Linux's handling of files that are in use—whether opened for reading, running as executables, or loaded as shared libraries—by experimenting with deletion, replacement, and modification, revealing how the kernel preserves file contents via inode references until all processes release them.
InodeLinuxShared Library
0 likes · 16 min read

This article details a systematic investigation of a Hadoop NameNode/DataNode that showed high memory usage at 3 AM, identifies zombie crond/sendmail/postdrop processes caused by a failed Postfix service, and provides cleanup commands and preventive measures for memory, disk, and inode issues.
HadoopInodeMemory Leak
0 likes · 5 min read

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.
InodeStoragecp command
0 likes · 11 min read

This guide explains Linux file I/O fundamentals, covering file concepts, standard streams, system calls like open and dup2, file descriptor allocation, redirection, the FILE structure, inode layout, hard and soft links, and the creation and usage of static and dynamic libraries, all illustrated with code snippets and diagrams.
Dynamic LibraryFile I/OInode
0 likes · 22 min read

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.
InodeLinuxblock indexing
0 likes · 11 min read

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.
FilesystemInodeLinux
0 likes · 11 min read

This article explains the concept of inodes in Unix/Linux filesystems, detailing their structure, stored metadata, size calculations, inode numbers, directory handling, hard and soft links, and the special behaviors that arise from separating file names from inode identifiers.
FilesystemHard LinkInode
0 likes · 9 min read

Even when a Linux system reports a full disk, deleted files may still occupy space because active processes keep them open; using commands like df, du, and lsof reveals hidden usage, and understanding the virtual file system, inode structures, and link management explains how to release the space.
Filesystem FundamentalsInodeLinux
0 likes · 11 min read

The article explains why Linux can report a full disk despite apparent free space, showing how deleted files held open by processes keep their blocks allocated, and walks through using df, du, and lsof to identify the issue, then details the virtual file system architecture, inode handling, and file‑deletion mechanics.
InodeVFSdisk space
0 likes · 12 min read

This article explains why a Linux system can report a full disk even after files are deleted, covering the role of open file handles, the lsof command, and the virtual file system architecture that manages inodes, dentries, and link counts.
InodeVFSdisk space
0 likes · 10 min read

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.
InodeLinuxProcess Management
0 likes · 12 min read

This article explains the fundamentals of inodes, sectors, and blocks, demonstrates how to retrieve file information with Node.js and Linux commands, compares hard and soft links, and shows practical applications of these links in frontend workflows such as yarn link and pnpm installation.
FilesystemHard LinkInode
0 likes · 14 min read

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.
I/OInodeLinux
0 likes · 16 min read

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.
InodeLinuxblock indexing
0 likes · 10 min read

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.
InodeLinuxStorage
0 likes · 11 min read

A colleague was amazed when the cp command copied a 100 GB file in less than a second, prompting an investigation that reveals the difference between logical file size and physical block usage, the role of inodes, direct and indirect block indexing, and how sparse files make such copies appear instantaneous.
Inodeblock indexingcp command
0 likes · 12 min read

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.
Inodeblock indexingcp command
0 likes · 10 min read

A colleague copied a 100 GB file in under a second, prompting an investigation that reveals how Linux file systems distinguish logical file size from physical storage using inodes, block allocation, direct and indirect indexing, and sparse file techniques that make such copies appear instantaneous.
InodeLinuxcp command
0 likes · 11 min read

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.
InodeStoragefile-system
0 likes · 11 min read

A colleague copied a 100 GB file with the cp command and it finished in under a second, prompting an investigation that reveals the difference between a file's logical size and its physical block usage, the role of inodes, direct and indirect block indexing, and how sparse files make such rapid copies possible.
InodeLinuxcp command
0 likes · 11 min read

This article explains why copying a seemingly 100 GB file with the cp command finishes almost instantly by exploring sparse files, the difference between file size and physical block usage, inode structures, multi‑level block indexing, and how modern file systems efficiently manage storage.
Inodecp commandfile-system
0 likes · 12 min read

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.
DBAInodeLinux
0 likes · 8 min read

This guide explains Linux inode basics, the differences between hard and symbolic links, their creation commands, limitations, and practical scenarios such as version switching, library management, shortcuts, file classification, shared editing, and space‑efficient backups.
FilesystemHard LinkInode
0 likes · 13 min read

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.
EXT4FilesystemInode
0 likes · 13 min read

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.
EXT4FilesystemHDD
0 likes · 13 min read

This article demystifies the three common Linux commands—ln, mv, and cp—explaining how they differ in handling inodes, dirents, and data blocks, when they create links or move files, and why their performance varies across file systems and file types.
Hard LinkInodeLinux
0 likes · 16 min read

This article explains the true nature of a file descriptor (fd) in Linux, tracing how the kernel represents open files through task_struct, files_struct, fdtable, and inode structures, and shows how these layers interact with system calls like open, read, write, dup, and fork.
InodeLinux kernelVFS
0 likes · 16 min read

This article explains how Linux stores file metadata in inodes, demonstrates the differences between hard and soft links through practical experiments, and provides a detailed walkthrough of the inode structure and its associated VFS operation functions.
Hard LinkInodeLinux
0 likes · 13 min read

This tutorial walks through building a tiny 1 MB file system using 1 KB blocks, block bitmaps, 128‑byte inodes, superblocks, directory structures, and single‑ and double‑indirect indexing, culminating in a design comparable to Linux's ext2 filesystem.
Ext2Inodeblock bitmap
0 likes · 13 min read

This article explains why the Linux cp command can duplicate a seemingly 100 GB file in less than a second by revealing how sparse files work, the role of inodes and block allocation, the different cp --sparse modes, and the underlying filesystem mechanisms such as fiemap, extent copying, and hole punching.
EXT4InodeLinux
0 likes · 40 min read

The article explains why Linux’s du and df commands often report inconsistent disk usage, detailing the underlying file‑system structures such as inodes, block maps, and superblocks, the processes of file creation and deletion, and how mounted partitions, open file handles, and stat calls affect each tool’s calculations.
InodeLinuxdf
0 likes · 12 min read

This article explains the design of Linux file systems, focusing on ext4's inode layout, block allocation, extents, directory storage, journaling modes, and the kernel's cached and direct I/O paths, complete with code snippets and structural diagrams.
EXT4InodeLinux
0 likes · 21 min read


ITPUBNov 4, 2020 · Operations
This article explains the core design of Linux file systems, covering strict organization, block and inode structures, ext4 formatting details such as extents and meta block groups, directory storage, journaling modes, and the kernel's cached and direct I/O paths for reading and writing files.
EXT4InodeLinux
0 likes · 21 min read

This article explains the core design of Linux file systems, covering strict organization, block allocation, inode structures, ext4 extent trees, block groups, superblock metadata, directory storage formats, and the kernel's cached and direct I/O paths for reading and writing files.
EXT4FilesystemInode
0 likes · 21 min read

The article explains why Linux can show a full disk despite apparent free space, detailing how deleted files remain occupied by open processes, the role of the virtual file system (VFS), inode structures, and how commands like lsof reveal these hidden usages.
InodeLinuxVFS
0 likes · 11 min read

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.
InodeLinuxVFS
0 likes · 11 min read

This guide shows how a file can appear deleted on Linux yet still occupy disk space, explains the inode reference‑count mechanism, demonstrates how to reproduce the issue with dd and a C program, and provides commands like lsof and /proc inspection to locate and release such hidden usage.
InodeLinuxc-programming
0 likes · 6 min read

This guide explains how Linux inodes identify identical files, demonstrates using ls -i, sort, and find -samefile commands, and provides a Bash script to automatically list hard‑linked duplicates, helping you reclaim disk space efficiently.
Hard LinksInodeLinux
0 likes · 6 min read

This article explains how Linux file deletion works, why space may not be released when a file is removed, and shows practical commands and a C example to illustrate inode reference counting, using tools like df, dd, lsof, and proper file‑descriptor handling.
Inodec-programdd
0 likes · 7 min read

This article explains why removing a file with rm on Linux sometimes leaves disk space unchanged, demonstrates the behavior with a random file and a C program that keeps the file open, and shows how to identify and release such lingering file allocations using inode reference counts and lsof.
Inodedisk spacefile-system
0 likes · 7 min read

This article explains what inodes are, why they can become exhausted even when disk space remains, and provides step‑by‑step Linux commands and cleanup techniques to monitor and resolve inode exhaustion issues.
FilesystemInodecleanup
0 likes · 6 min read

This article explains how Linux formats disks using mkfs, detailing block size, inode and block counts, block groups, directory structures, and how to choose appropriate parameters for different workloads to achieve optimal storage efficiency and performance.
FilesystemInodeLinux
0 likes · 10 min read

The article explains how directories consume inodes and filesystem blocks, how this consumption grows with many files or long filenames, and why the ls command can become sluggish, offering practical tips to mitigate the performance impact.
EXT4InodeLinux
0 likes · 8 min read

A file containing just one byte still consumes 4KB of disk space due to filesystem block allocation, plus inode and directory overhead.
Block SizeExt2Inode
0 likes · 5 min read

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.
InodeLinuxMount
0 likes · 12 min read

This article explains the concept of inodes, their contents, size, numbering, relationship with directories, hard and soft links, special behaviors in Unix/Linux, and provides a real‑world troubleshooting example for inode exhaustion.
Filesystem FundamentalsHard LinkInode
0 likes · 11 min read


ITPUBJan 10, 2020 · Fundamentals
This article explains Unix/Linux inodes—the metadata structures that store file information—covering their purpose, contents, size considerations, inode numbers, directory handling, hard and soft links, and special inode-related operations, with practical command examples and visual illustrations.
Hard LinkInodeLinux
0 likes · 10 min read

This article explores the evolution, architecture, and key features of Linux EXT filesystems—including Minix origins, EXT2, EXT3, and EXT4—detailing metadata structures, inode handling, fragmentation mitigation, journaling, and practical upgrade and maintenance considerations.
EXT4File System ArchitectureFilesystem
0 likes · 20 min read

This article explains Linux's hierarchical file system, detailing how the root directory, partitions, boot and super blocks, inodes, and data blocks interact to store and retrieve files, and it also covers file descriptors, sharing, and process forking.
InodeLinuxStorage
0 likes · 10 min read

This article presents a systematic troubleshooting workflow for Linux operations engineers, covering six typical problems—including filesystem corruption, disk‑space exhaustion, inode depletion, deleted files that still occupy space, too many open files, and read‑only filesystems—along with concrete commands and solutions to resolve each issue.
FilesystemInodeLinux
0 likes · 13 min read

This guide walks you through a systematic approach to diagnosing and resolving nine frequent Linux system problems—from read‑only file systems and argument‑list limits to inode exhaustion, space‑not‑released files, too many open files, and Apache startup failures—providing clear command‑line solutions for each.
InodeLinuxerror handling
0 likes · 18 min read

A Linux server became unreachable with a massive load average of 360 due to exhausted inodes caused by a runaway postdrop process, and the issue was resolved by cleaning the maildrop directory and silencing the offending cron job.
InodeLinuxcron
0 likes · 5 min read

This article explains the concept of an inode, its role in storing file metadata, its size and structure on disk, how inode numbers are used, and the differences between hard links, soft links, and directory entries in Unix/Linux systems.
Hard LinkInodeLinux
0 likes · 9 min read

This article explains how Linux represents files and directories with inodes, how file and directory counts and nesting depth affect disk I/O during lookup, and shows how to monitor inode usage to determine performance thresholds.
FilesystemInodeLinux
0 likes · 7 min read
