The article explains PHP's chown() function, detailing its purpose, syntax, parameters, return values, and provides a complete example with code and expected output for changing a file's owner on a server.
The PHP chmod function changes a file's permission mode by specifying the file path and an octal mode value, returning true on success and false on failure, with detailed parameter descriptions and multiple code examples illustrating correct and incorrect usage.
The article explains PHP's getcwd() function, detailing its purpose, syntax, return values, edge‑case behavior on Unix systems, and provides a complete example demonstrating how to echo the current directory before and after changing it.
This article explains the PHP chdir() function, its syntax, parameters, return values, and provides a practical example showing how to change the current working directory and verify the change using getcwd().
The PHP rmdir() function removes an empty directory with proper permissions, returning TRUE on success or FALSE on failure, and the article explains its parameters, return values, and provides cross‑platform code examples for safely deleting directories.
This article explains the PHP mkdir() function, detailing its signature, parameter meanings, default mode, recursive option, return values, and provides two practical code examples demonstrating simple directory creation and nested directory creation with error handling.
This article provides a comprehensive overview of Linux’s core architecture, detailing the kernel, shell, memory and process management, virtual file system, various file system types, directory structures, partitioning, mounting procedures, and link mechanisms, offering readers a solid foundation for mastering Linux systems.
This comprehensive guide explores Linux's core components—including the kernel, shell, memory and process management, file systems, device drivers, network interfaces, mounting mechanisms, and link types—providing clear explanations, diagrams, and command examples for anyone learning operating system fundamentals.
This article walks through the design and implementation of a tiny Linux filesystem called TinyFS, explaining the VFS layers, required POSIX interfaces, data structures, core kernel code, usage steps, current limitations, and a roadmap for extending it with proper superblocks, concurrency, and page‑cache integration.
This article explains PHP's realpath() function, detailing its purpose of returning a normalized absolute pathname, describing its parameters and return values, and providing two practical code examples that demonstrate path resolution on Unix and Windows systems.
This article explains the PHP linkinfo() function, detailing its purpose of retrieving filesystem link information, the required string $path parameter, the return of the st_dev field from lstat (or 0/FALSE on error), and provides a concise usage example.
This article explains PHP's readlink() function, detailing its purpose of returning a symbolic link's target, the required path parameter, return behavior on success or failure, and provides a concise example demonstrating its usage.
This article explains the PHP is_link() function, its purpose of checking whether a given filename is a symbolic link, details its parameter and return values, and provides two practical code examples demonstrating how to use it for link detection and handling.
The article explains PHP's is_dir() function, detailing its signature, parameter description, return values, and provides two practical code examples demonstrating how to check if a path is a directory and handle the result.
The article explains PHP's is_file() function, detailing its signature, parameter description, return values, important notes on large files and caching, and provides two practical code examples demonstrating how to check for regular files.
The article explains PHP's file_exists() function, detailing its syntax, parameter requirements, return values, safe‑mode warning, and provides two practical code examples demonstrating how to check for the existence of files or directories.
This guide explains how to add virtual disks to a Linux VM, identify them, create partitions with fdisk, format them with XFS or ext4, mount and unmount the filesystems, and configure automatic mounting at boot using /etc/fstab.
The article explains why a large log file appears to occupy several gigabytes with `ls` yet only a few megabytes with `du`, covering file deletion semantics, open file handles, the difference between apparent size and disk usage, and how sparse files cause this discrepancy.
This article walks through building a Docker image, explains the Union File System underlying Docker's layered storage, analyzes image and container file system structures, and presents practical Dockerfile optimization techniques to reduce image size and improve build efficiency.
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.
This article provides a comprehensive guide to Python's os module, detailing common file and directory operations such as creating folders, listing files, deleting files, and retrieving file attributes, with syntax, descriptions, and code examples for each function.
This concise guide presents Laravel’s File facade methods for common file and directory operations, covering existence checks, reading, writing, moving, copying, permission handling, and cleanup, with clear code examples for each function.
This article introduces Linux as the world’s most popular operating system, explains why it’s widely used in servers and supercomputers, outlines its Unix‑based philosophy, describes the standard filesystem hierarchy, and walks through essential command‑line basics and common commands for new users.
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.
This article explores whether creating an empty file with the touch command consumes disk space on Linux, revealing that each empty file uses one inode and a small amount of directory block space, and explains inode structures, related commands, and a real‑world inode exhaustion incident.
This article explains the role of HDFS SecondaryNameNode, the structure of fsimage and edits files, how checkpointing works—including configuration parameters and steps—and how the process changes when NameNode high availability is enabled.
This article traces the historical evolution of the Unix directory hierarchy, showing how early storage limitations and the addition of multiple disks led to the creation of distinct directories like /bin, /usr/bin, /usr/local, and /opt, and why those conventions persist today.
The guide shows how to enlarge storage on a Tencent Cloud Linux VM by adding and expanding CBS cloud disks using three approaches—direct bare‑device formatting, MBR partitioning for disks under 2 TB, and GPT partitioning for larger disks—detailing step‑by‑step commands, online vs offline resizing, and best‑practice recommendations.
An extensive guide walks through Linux’s core components—kernel, memory and process management, VFS, device drivers, networking, shells, filesystem hierarchy, partitioning, mounting, and link types—detailing their structures, key commands, and practical examples for system administrators and developers.
This article explains how lxcfs uses FUSE and cgroup technology to isolate /proc and /sys files inside containers, showing the implementation details of cpuonline and loadavg handling, and includes key source code snippets that illustrate the isolation mechanism.
Explore the core concepts of GNU/Linux, including the GNU project and GPL license, Linux distributions, Unix heritage, swap partitions, GRUB bootloader, buffer vs cache, TCP three-way handshake, directory hierarchy, hard and symbolic links, and RAID storage levels, all explained in clear detail.
This article provides a concise overview of core Linux concepts, covering the GNU project and GPL license, common distributions, swap partitions, GRUB bootloader, buffer vs cache, TCP three-way handshake, filesystem hierarchy, hard and symbolic links, and an introduction to RAID levels and their characteristics.
This guide walks through diagnosing a busy /home mount, installing missing tools, safely unmounting, resizing the home partition, installing XFS utilities, and finally expanding the root filesystem on a CentOS 7 server.
This guide details common MooseFS mounting problems—including bad mount points, firewall port blocks, error messages, and incomplete disk scans—and provides step‑by‑step commands such as killing processes, unmounting, remounting, and checking services to resolve these issues.
This article compiles a series of Linux mind‑maps and diagrams that outline learning paths, desktop environments, the Filesystem Hierarchy Standard, critical directories, kernel study routes, security coaching visuals, and command reference cheat sheets, each linked to their original sources.
Learn step‑by‑step how to identify an unmounted 160 GB disk on a Linux server, create the necessary LVM partitions, extend the volume group and logical volume, and resize the filesystem—all without rebooting—using commands such as df, fdisk, pvcreate, vgextend, lvextend, and xfs_growfs.
This guide outlines essential Python os and shutil functions for file and directory manipulation, covering path queries, creation, deletion, permission changes, environment variables, and common file opening modes, providing concise examples for each operation.
This article explains the history, purpose, and structure of the Linux Filesystem Hierarchy Standard (FHS), detailing the classification of directories, their typical contents such as /, /usr, /var, and the distinctions between shareable, non‑shareable, immutable, and mutable directories, with practical examples.
This comprehensive guide introduces the GNU project and GPL license, outlines typical Linux distributions, explains Unix roots, swap partitions, GRUB bootloader, buffer vs cache, TCP three-way handshake, Linux directory hierarchy, hard and symbolic links, and RAID levels, providing essential Linux fundamentals for beginners.
This guide explains the purpose and typical contents of each major Linux directory—from /bin and /sbin for essential binaries to /etc for configuration files, /proc for virtual system information, and /usr, /var, /home for user data and applications—providing a comprehensive overview for system administrators and developers.
A comprehensive cheat‑sheet of Linux system administration commands and scripts covering mounting Windows shares, monitoring HTTP concurrency, packet sniffing, log analysis, file system inspection, process metrics, boot sequence, link types, partition handling, user management, and networking utilities.
This article explains Linux ACL permission management, covering the concepts, how to check and enable ACL support on partitions, and detailed commands for setting, viewing, masking, deleting, recursive, and default ACLs to securely control file and directory access for users and groups.
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.
This article explains the XFS file system’s key features such as data integrity, performance, scalability and bandwidth, and provides step‑by‑step instructions for downloading kernel patches, enabling XFS support, compiling the kernel, creating and mounting XFS partitions, and migrating existing Linux systems to XFS.
This article provides a comprehensive overview of Linux fundamentals, covering how to select a distribution, the kernel and system architecture, essential filesystem hierarchy, common shell commands, and typical applications for both server and desktop environments.
This article introduces the fundamentals of Linux and open‑source software, covering GNU and GPL licensing, typical Linux distributions, Unix roots, swap partitions, GRUB bootloader, buffer vs cache, TCP three‑way handshake, filesystem hierarchy, hard/soft links, and an overview of RAID levels.
This guide walks through a real‑world case where a virtual machine shows only ~30 GB free while a hidden 160 GB disk is detected, and demonstrates step‑by‑step how to use LVM to add, partition, and resize the disk without restarting the system.
This guide explains how Linux manages storage as a single root hierarchy and details the purpose and typical contents of key directories such as /home, /bin, /dev, /etc, /usr, /var, and others, including quick commands to navigate to your home folder.
Learn step-by-step how to attach an unmounted 160 GB disk to a Linux server and expand its LVM logical volume without rebooting, covering disk inspection, partitioning, PV creation, VG extension, LV resizing, and filesystem growth using df, fdisk, pvcreate, vgextend, lvextend, and xfs_growfs.
Learn a systematic Linux troubleshooting workflow and detailed solutions for six typical operational problems—including filesystem corruption, disk space exhaustion, inode depletion, lingering deleted files, too‑many‑open‑files errors, and read‑only filesystem issues—complete with command‑line examples and step‑by‑step fixes.
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.
This guide explains essential Linux storage commands—including fdisk, df, du, mount, and umount—covers automatic mounting via /etc/fstab, details disk partitioning with fdisk, and demonstrates how to format partitions using mkfs, providing practical examples for each step.
After a sudden incident deleted files from /data/webapps/xxxx/upload without backup, this guide walks through installing extundelete, locating the deleted inode data, and using extundelete commands to recover as much of the lost data as possible, including tips on mounting read‑only.
The article explains that the ls command becomes slow on directories containing millions of files because it repeatedly calls the getdents system call through readdir, and demonstrates how directly using getdents with a larger buffer can reduce the listing time from several seconds to under one second.
This article provides a comprehensive overview of core Linux concepts, including the GNU project and GPL license, common distributions, swap partitions, GRUB bootloader, buffer vs cache, TCP three-way handshake, filesystem hierarchy, hard and soft links, and RAID technology.
Learn a systematic approach for Linux system administrators to diagnose and resolve six typical problems—including filesystem errors, 'argument list too long', inode exhaustion, undeleted file space, too many open files, and read‑only filesystem—using command‑line tools, log analysis, and practical fixes.
This article provides a comprehensive overview of Linux fundamentals, covering distribution choices, kernel architecture, core components, filesystem types, standard directory hierarchy, shell usage, and common applications for both server and desktop environments.
This article explains the historical evolution of Unix directory structures, detailing why directories like /bin, /usr/bin, /usr/local/bin, and /opt/bin exist and how early disk‑based designs shaped the layout we use today.
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 guide walks through the safe preparation, partitioning, formatting, and mounting of a newly purchased data disk on an ECS instance, including device name discovery, creating an ext3 filesystem, updating /etc/fstab, and verifying the mount, with all necessary Linux commands.
This article compiles essential information about Linux’s core directories—/etc, /usr, /var, /proc, and /dev—detailing their purposes, typical contents, and how they fit into the overall filesystem hierarchy, complemented by illustrative diagrams for developers and administrators.
This article explains why the Linux commands df and du often report different disk usage figures, detailing three main causes—reserved space, phantom (deleted) files, and data present before mounting—and provides concrete commands and steps to identify and resolve each discrepancy.
The article explains hard‑disk physical structure, how seek time, rotational latency and transfer rate determine IOPS and throughput, and describes Linux I/O stack optimizations—such as caching, scheduling, and append‑only or LSM‑tree designs—to mitigate random‑access bottlenecks and improve overall storage performance.
This article outlines practical Linux‑based optimization techniques for MySQL, covering CPU power‑saving modes, NUMA and vm.swappiness settings, as well as mount options and I/O scheduler tweaks to maximize database throughput and stability.
This article lists the main top‑level directories in a typical Linux filesystem—such as bin, sbin, etc, usr, home, root, dev, lib, mnt, boot, tmp, and var—and explains the purpose of each directory.
This guide explains Linux directory structures, absolute and relative paths, and provides detailed usage, options, and examples for common commands such as ls, cd, pwd, mkdir, rmdir, cp, rm, mv, and file‑viewing tools like cat, tac, nl, more, less, head, and tail.
An embedded‑system developer discovers that FatFs reports FR_NO_FILESYSTEM on a correctly formatted SD card because the card’s partition information resides in the fourth MBR entry, which FatFs only checks in the first entry, and resolves the issue by re‑formatting with f_mkfs or upgrading to FatFs V0.10.
This guide explains how a mistaken script moved and deleted Linux image files, then details step‑by‑step recovery using TestDisk/PhotoRec, the qphotorec GUI, and EasyRecovery, highlighting search strategies, common pitfalls, and results with restored filenames and metadata.
This article provides a comprehensive overview of RAID technology, explaining its purpose, the various standard levels from RAID 0 to RAID 6, hybrid configurations, non‑standard implementations like DRFS, and both software and firmware/driver based deployment methods.
This guide walks through creating Linux LVM physical volumes, volume groups, and logical volumes on four 1 GB disks, demonstrates formatting, mounting, extending, shrinking, and snapshotting volumes, and provides the necessary commands for managing and removing LVM components.
This guide details Linux OS tuning for SSDs, covering ext4 TRIM, noatime, I/O scheduler selection, write cache activation, swap and cache pressure adjustments, tmpfs temporary directories, and Firefox cache relocation to improve performance and longevity.
This guide explains why Linux systems report "no space left on device" or read‑only file systems, shows how to inspect disk usage, inodes, and hardware health with commands like df, du, mount, smartctl, hddtemp, and provides step‑by‑step remediation techniques such as cleaning files, compressing logs, remounting, and repairing filesystems.
This article explains the disk layout of ext3 and ext4 filesystems, the mechanisms behind online resizing, and how meta block groups overcome the limitations of reserved descriptor blocks, providing a clear understanding for Linux system administrators.
This guide walks through creating an XFS filesystem on a new partition, configuring LVM physical, volume, and logical volumes, formatting with XFS, enabling user and group quotas, assigning quota limits, testing quota enforcement, and finally expanding the logical volume and growing the XFS filesystem.
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.
