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 the PHP file_exists() function works, shows its basic syntax, provides local and remote file existence examples with code, and highlights important considerations such as correct paths, permissions, and potential HTTP overhead.
This guide explains how to use Linux’s mount command to attach local disks, network shares, and ISO images, covering basic syntax, common options like -t and -o, automatic mounting via /etc/fstab, and important security considerations.
This article explains how the PHP file_exists() function works, its syntax, return values, usage examples for local and remote files as well as directories, and important considerations when employing it in backend development.
This article explains PHP's is_dir() function, demonstrates how to determine whether a given path is a directory, and provides practical code examples for simple checks and recursive directory traversal, highlighting important usage considerations and related filesystem functions.
This article explains PHP's is_dir() function, demonstrates basic and advanced usage with code examples for checking whether a path is a directory and recursively traversing directory contents, and highlights important considerations such as path existence and permissions.
When a Linux application's data directory runs out of space, using mount --bind instead of layered symlinks lets you transparently redirect the directory to a larger disk, with clear steps, underlying principles, and advanced read‑only or temporary configurations.
This article explains PHP's copy() function, detailing its syntax, parameters, return values, example usage, and important precautions for safely copying files on the server, including handling of existing destination files, limitations with directories, and cross‑filesystem considerations.
This article explains PHP's mkdir() function, detailing its syntax, parameters, return values, and providing practical examples for creating single directories, recursive directories, setting permissions, and using optional stream contexts, along with code snippets and explanations of each argument's effect.
This article explains PHP's dirname() function, detailing its syntax, parameters, and practical examples for extracting directory paths, handling multiple levels, and processing relative paths, while highlighting important usage considerations in various development scenarios.
The PHP stat() function returns an associative array containing detailed file metadata such as size, device ID, inode, permissions, timestamps and block information, and can be used by passing a filename to retrieve and display these attributes via array keys.
The article explains PHP's is_file() function, its syntax, parameters, return values, provides code examples for checking regular files, outlines important usage considerations, and offers a complete example combined with file_exists() to safely determine file existence and type.
The article explains PHP's built‑in is_executable() function, detailing its syntax, the $filename parameter, possible true/false return values, example code for checking file executability, important notes on directory checks and permission effects, and provides a brief summary.
The article explains the PHP is_readable() function, detailing its syntax, parameters, example usage, notes, error handling, and best practices for checking file readability before performing file operations.
This article explains how to use PHP's fileatime() function to retrieve a file's last access timestamp, demonstrates basic and advanced usage with code examples, shows how to check whether a file has been accessed, and illustrates implementing simple access count tracking.
This article explains the PHP filesize() function, covering its prototype, required $filename parameter, possible return values, practical code examples, important usage considerations, and extended applications such as checking for empty files.
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.
This article provides a detailed overview of Linux fundamentals, covering the directory structure, essential command-line operations, file permission management, user and group administration, process monitoring and termination, as well as common software installation methods using tar, rpm, and yum.
This article provides a comprehensive introduction to Linux, covering the operating system concept, installation guide, directory structure, essential commands for navigation, file manipulation, user and group management, permission handling, and basic process control techniques.
This guide demystifies the Linux filesystem hierarchy by explaining the purpose of each top‑level directory—such as /bin, /etc, /home, /var, and /usr—and shows where common types of files should be placed for a well‑organized system.
This article provides PHP code examples for recursively removing files and folders, explains the use of unlink() and rmdir() functions, and demonstrates how to delete all ".svn" directories along with their contents.
This guide demystifies the Linux filesystem hierarchy by explaining the purpose of each top‑level directory—such as /bin, /etc, /home, /var, and /usr—and shows where different types of files should be stored for a clean, well‑organized system.
This guide outlines eight practical Linux performance‑tuning methods—including kernel parameter tweaks, filesystem and network optimizations, process priority adjustments, memory management, scheduler configuration, software bloat removal, and log cleanup—while showcasing key tools and visual diagrams for effective system optimization.
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 the structure of Linux Ext (2/3/4) filesystems, detailing superblocks, inode tables and data blocks, then describes block groups, the role of superblocks, and outlines the differences between hardware and software RAID as well as the principles and risks of using LVM for flexible storage management.
Explore the Linux filesystem hierarchy in depth, learning the purpose of each top‑level directory—from /bin and /boot to /var and /usr—and discover where to correctly place different types of files for a clean, well‑organized system.
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 guide demystifies the Linux Filesystem Hierarchy Standard by explaining the purpose of each top‑level directory—such as /bin, /etc, /home, /var, and others—and shows where different types of files should be stored for a clean, maintainable system.
This article provides a comprehensive overview of Linux fundamentals, covering its basic concepts, essential commands, learning roadmaps, desktop environments, the Filesystem Hierarchy Standard, important directories, kernel study paths, security considerations, and includes reference tables and a community invitation.
This guide walks you through Linux file system mounting techniques—including manual mounts for ISO images, USB drives, Windows shares, and NFS—as well as permanent fstab entries and automated mounting with autofs, complete with command examples and configuration tips.
This guide introduces Linux fundamentals, walks through essential command‑line tools, explains the Filesystem Hierarchy Standard and key directories, outlines a structured learning path for the kernel and desktop environment, and provides security tips, command references, and a handy cheat‑sheet.
Learn how to replace cumbersome symlinks with Linux’s mount --bind command, covering basic usage, step‑by‑step examples, underlying VFS mechanics, persistence via /etc/fstab, and advanced scenarios such as temporary configuration testing and read‑only mounts.
This comprehensive guide explains Linux's core components—including the kernel, shell, memory and process management, virtual file system, device drivers, networking, and mounting—while detailing filesystem types, directory structures, link types, and practical commands for managing partitions and mounts.
This article explains the implementation of fragment deduplication in the erofs-utils mkfs tool, describing the hash‑based fragment lookup, the conditions for fixing fragments during compression, the generation of additional extents, and the integration of these steps into the existing packing workflow.
This guide explains how to use the Linux df command with real‑world examples, covering human‑readable output, inode statistics, total usage, filesystem types, inclusion/exclusion filters, specific mount points, and virtual filesystems to help you monitor disk space effectively.
This article provides a comprehensive guide to Linux fundamentals, covering OS concepts, installation steps, filesystem hierarchy, essential command-line tools, user and group management, permission handling, process control, and common software installation methods.
Node.js v19.1.0 introduces function mocking in the test runner, recursive file‑system watching support, updated ICU, documentation collaborator additions, removal of experimental fetch warnings, MIME utilities, and performance improvements for text decoding, providing a comprehensive set of backend enhancements.
This article demonstrates how to use a Python script to automatically categorize and move files on the desktop or in any folder into type‑based subfolders by defining custom file‑extension groups, scanning directories, creating target folders, and moving matching files, with complete code examples and execution instructions.
Rocky Linux 9 builds on RHEL 9 with the open‑source Peridot build system and introduces major security upgrades, modern networking tools, GNOME 40 desktop improvements, and filesystem enhancements like XFS DAX support, positioning it as a compelling RHEL‑compatible enterprise OS.
The article explains how Nydus’s new RAFS v6 image format, built on the kernel‑native EROFS filesystem and integrated with fscache, overcomes the performance and scalability limitations of traditional OCIv1 and user‑space container image solutions by enabling kernel‑mode on‑demand loading, fine‑grained chunk deduplication, asynchronous prefetching, and superior I/O efficiency, with benchmark results demonstrating near‑native speeds.
This article explains the Linux FS‑Cache subsystem, detailing how it creates local disk caches called cookies, the structures and workflows of volume, data‑file, and cache cookies, and the mechanisms for allocation, hashing, state‑machine transitions, and cleanup.
This guide compiles practical Linux one‑liners for sorting directories by size, listing subdirectories, monitoring disk usage changes, removing unwanted .svn folders, checking inode and partition statistics, and measuring read/write performance, providing sysadmins with quick, actionable tools.
The article examines the lack of maintenance for the newly merged NTFS3 Linux driver, discusses Linus Torvalds' invitation for new maintainers, and outlines recent community efforts to keep the driver functional and up‑to‑date.
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.
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.
A recent hardware failure left a physical server's disk read‑only, causing Redis to hang; this article explains the AOF mechanism, its potential pitfalls, log strategies, and practical steps to prevent and mitigate such issues in production environments.
This article explains the design and implementation of the EROFS tail‑packing inline compression feature merged in Linux kernel 5.17, covering modifications to the on‑disk format, mkfs and kernel code paths, new inode structures, map‑block handling, and performance considerations with detailed code excerpts.
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.
This article explains the Linux Filesystem Hierarchy Standard (FHS), describes the purpose and typical contents of each top‑level directory such as /home, /boot, /etc, /usr, and /var, and demonstrates essential shell commands for navigating and managing these directories, including absolute and relative paths.
This guide explains the Linux Filesystem Hierarchy Standard (FHS), the purpose of each top‑level directory, the difference between absolute and relative paths, and provides practical command examples for navigating and managing directories safely and efficiently.
This article presents a detailed performance comparison of npm, Yarn, PNPM, CNPM, and npm rapid, then explains three core optimization techniques—request aggregation, a middle‑layer file system, and cache layering—to reduce installation time by up to tenfold while addressing disk‑space challenges.
This article explains why Linux utilities like du and ls can report dramatically different file sizes, introduces the concept of sparse files, and shows practical commands to identify and correctly handle them on Unix-like systems.
This article explains why the Linux commands du and df often return mismatched root partition sizes, detailing five underlying reasons such as deleted open files, reserved space, hidden files, mounted directories, and the fundamental differences between how du and df calculate disk usage.
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.
This article provides a comprehensive overview of Linux's core components—including the kernel, shell, virtual file system, memory and process management, device drivers, networking, and disk partitioning—explaining their roles, structures, and how they interact within the operating system.
This article provides a comprehensive overview of Linux system architecture, covering the kernel, memory and process management, virtual and physical filesystems, device drivers, networking, shell types, file types, directory structures, partitioning, mounting, and link mechanisms, all illustrated with diagrams and command examples.
This guide explains why ls -lh shows only the directory entry size, introduces the du command for real disk usage, details its most useful options, and provides step‑by‑step examples for measuring directory sizes on a Linux system.
This guide explains the purpose and typical contents of each standard Linux directory—from /bin and /sbin for system binaries, through configuration files in /etc, device nodes in /dev, to variable data in /var and virtual information in /proc—providing a comprehensive overview of the Linux filesystem hierarchy.
OverlayFS is a stacking file system that merges lower and upper directories into a single view using mount options like lowerdir, upperdir, and workdir, supports copy‑up, whiteouts, opaque directories and configurable rename handling, and is employed in Android, OpenWRT, and container platforms to provide writable overlays on read‑only layers.
This article traces ZFS’s origins from its 2001 inception at Sun, outlines its open‑source evolution, and delves into core concepts such as storage pools, block management, copy‑on‑write, snapshots, deduplication, and the intricate transaction model that underpins its reliability.
This guide explains how to use the Linux findmnt command—including installation, default listing, real‑time monitoring, df‑style output, list format, fstab parsing, label evaluation, and filesystem‑type filtering—providing practical examples and command syntax for system administrators.
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.
The PHP scandir function returns an array of filenames and sub‑directories from a given directory, optionally sorted in ascending or descending order, and can accept a stream context, providing FALSE on failure and generating a warning if the path is not a directory.
This article explains PHP's opendir function, which opens a directory handle for subsequent closedir, readdir, and rewinddir operations, details its parameters and return values, and provides a complete example script demonstrating how to read directory contents and output file names with their types.
This comprehensive tutorial explains how to enable and configure Linux Disk Quota on XFS filesystems, covering prerequisites, quota modes, user and directory limits, grace periods, testing scenarios, and essential administration commands for effective storage management.
The article explains the PHP getcwd() function, its return values, permission considerations on Unix variants, and provides a clear code example demonstrating how to obtain and change the current working directory using echo and chdir.
The article explains PHP's dir() function, detailing its parameters, return values, and providing a complete example that demonstrates opening a directory, retrieving its handle and path, iterating over entries, and closing the directory resource.
The PHP closedir function closes a directory handle opened by opendir, accepting a resource parameter and returning TRUE on success or FALSE on failure, with usage examples and parameter details for backend filesystem operations.
The article explains PHP's chroot function, detailing its purpose of changing the process root directory, required environment and permissions, parameters, return values, and provides a practical code example demonstrating its usage.
This article explains PHP's chdir function, detailing its syntax, parameters, return values, and provides a practical example demonstrating how to change the current working directory and verify the change using getcwd in a script.
This article explains the object‑oriented design of the Linux VFS, details the four core VFS structures, shows how ext4 is registered and mounted via register_filesystem and ext4_mount, and walks through the six‑step ext4_fill_super process for initializing superblocks and related metadata.
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 four core parts of a Linux system—kernel, shell, filesystem and applications—covering memory and process management, VFS architecture, file types, directory hierarchy, partitioning, mounting, links and essential command‑line tools.
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.
This article provides a comprehensive overview of Linux's core components—including the kernel, shell, virtual file system, various filesystem types, directory hierarchy, disk partition schemes, mounting procedures, and linking mechanisms—while illustrating key concepts with commands, code snippets, and diagrams for practical system administration.
The PHP function zip_entry_filesize() returns the actual byte size of a zip archive entry, taking a zip_entry resource obtained from zip_read() as its sole parameter and providing the entry's size as the return value.
This article demystifies the Linux I/O stack by tracing a single‑byte read through system calls, VFS, page cache, filesystem layers, block management and I/O scheduling, revealing when real disk I/O occurs and how much data is actually transferred.
This article introduces the Linux filesystem hierarchy, explains typical directories, provides solutions for MobaTextEditor garbled text, and offers a concise guide to Vim modes, settings, search/replace commands, and useful shell scripts for system administrators.
This article explains the Linux I/O stack, the flow of data from user‑space buffers through libc buffers, page cache, and kernel buffers to the physical disk, covering functions like fwrite, fflush, fsync, O_DIRECT, scheduling algorithms, consistency issues, and performance considerations.
The PHP function zip_entry_filesize returns the actual size of a zip archive directory entry, takes a zip_entry resource obtained from zip_read(), and can be used together with zip_entry_name in example code to list file names and their original sizes.
The article provides a comprehensive technical guide on Flink's FileSystem, JDBC, and Kafka connectors, detailing their source and sink implementations, core code logic, checkpoint handling, partition commit strategies, and complete SQL usage examples for streaming applications.
This article explains PHP's scandir() function, detailing its syntax, parameters, return values, and provides sample code demonstrating directory listing with optional sorting and context options, along with the expected output for developers.
The PHP rewinddir() function resets a directory handle opened by opendir() back to the start of the directory stream, returning the handle on success or FALSE on failure, and is illustrated with a complete example that reads, rewinds, and reads the directory contents again.
The PHP readdir() function reads the next entry from an opened directory handle, returning the filename in filesystem order, with details on its parameters, return values, and example code demonstrating correct and incorrect directory traversal techniques.
This article explains PHP's opendir() function, detailing its purpose of opening a directory handle, the required path and optional context parameters, the return values, and provides a complete code example that reads and displays filenames and their types within a specified directory.
This article explains the PHP getcwd() function, which retrieves the current working directory, details its return values, provides a sample script demonstrating its usage with chdir(), and shows the expected output paths.
The article explains the PHP closedir() function, which closes a directory handle opened by opendir(), describes its parameter and lack of return value, and provides a complete example demonstrating how to open, read, and close a directory in PHP.
This guide explains how PHP’s chdir() function changes the script’s current working directory, details its syntax, parameters, and return values, and provides a clear example showing before‑and‑after directory paths.
This article explains the concepts of Linux hard and soft (symbolic) links, demonstrates how to create and inspect them with the ln command, and outlines their characteristics, advantages, and limitations compared to Windows shortcuts.
This comprehensive guide explores Linux's four main components—kernel, shell, filesystem, and applications—detailing kernel architecture, memory and process management, VFS, device drivers, networking, file types, directory structures, mounting, and practical commands for managing partitions and links.
This article explains why file writes are non‑atomic, illustrates the risks of partial writes, and details how journaling (write‑ahead logging) and its variants—data and metadata journaling—ensure filesystem consistency and performance on Linux systems.
This article explains what inodes are, why they can become exhausted despite available disk space, and provides practical Linux commands and preventive steps to identify and resolve inode exhaustion issues.
The article explains what inodes are, why they can become fully consumed even when disk space remains, and provides step‑by‑step Linux commands and cron adjustments to identify the offending directories, delete excess files, and prevent future inode exhaustion.
The article explains what inodes are, why they can become fully consumed even when disk space remains, how to monitor inode usage with df -i, and provides practical steps and command‑line scripts to locate offending directories, delete excess files, and prevent future inode exhaustion on Linux systems.
The article introduces Nydus, an open‑source container image acceleration solution that replaces the traditional tarball‑based OCI format with a user‑space file system, enabling on‑demand loading, chunk‑level deduplication, secure distribution via Dragonfly, and demonstrates its large‑scale deployment success during Alibaba's 2020 Double‑11 event and in production workloads.
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.
The article introduces Nydus, an open‑source container image acceleration service co‑developed by Ant Group and Alibaba Cloud, explaining its architecture, on‑demand download, data deduplication, end‑to‑end consistency, OCI compatibility, and how it speeds up container startup while enhancing security.
This article provides a comprehensive, step‑by‑step explanation of Linux fundamentals—including the kernel architecture, process and thread creation, memory management, filesystem structures, I/O handling, and built‑in security mechanisms—illustrated with code snippets and diagrams.
This article provides an in‑depth tutorial on Linux fundamentals, covering the kernel architecture, process and thread creation, inter‑process communication, scheduling algorithms, virtual memory management, paging, caching, file system structures (VFS, ext2/ext4), network file systems, I/O device handling, loadable modules, and the operating‑system security model with permissions and setuid mechanisms.
This comprehensive guide breaks down the four main parts of a Linux system—kernel, shell, filesystem and applications—detailing kernel subsystems such as memory and process management, shell variants, file types, directory hierarchy, partition handling, VFS, mounting procedures, link types and essential command‑line tools, while also touching on application bundles and kernel parameter tuning.
