A sudden disk‑usage alarm reveals MySQL's ibtmp1 file ballooning to 192 GB, prompting a step‑by‑step investigation that explains the file’s purpose, shows how to clear and cap its size, and demonstrates how inefficient SQL queries can trigger such runaway growth.
When a Linux server reports a full disk, this guide walks you through eight essential commands to diagnose whether the issue is actual space exhaustion, inode depletion, lingering deleted files, or I/O bottlenecks, and provides a systematic cleanup workflow for production environments.
This article explains how MySQL binary logs can rapidly consume disk space, analyzes the root causes such as log format and workload, provides step‑by‑step diagnostics, and offers practical cleanup, configuration, replication, monitoring, and recovery strategies to prevent and resolve the issue.
This comprehensive guide explains MySQL binary log fundamentals, why they consume disk space, how to diagnose growth issues, and provides step‑by‑step cleanup, configuration, monitoring, and recovery strategies for both primary and replica servers.
This guide walks through a step‑by‑step process for identifying the partitions and files that fill a disk, applying temporary fixes to bring usage below critical levels, and implementing long‑term measures to prevent future disk‑full incidents in production environments.
This guide shows several efficient Linux commands—du, find, ls, and ncdu—to locate large files, sort results, and safely remove unnecessary data, helping you manage disk space before it runs out.
This guide walks you through a complete Linux disk‑space troubleshooting workflow, from quickly checking usage and inode status, to locating large files with du, ncdu or dust, handling deleted‑but‑still‑open files, cleaning logs, Docker images, temporary data, adjusting reserved space, and setting up monitoring and alerts.
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.
A senior cloud operations engineer receives a P1 alert for a web‑gateway server nearing 100% /var disk usage, then systematically logs in, diagnoses the log‑file bloat with df, du, and tail, truncates the offending debug log, and implements post‑mortem fixes to prevent recurrence.
This guide explains why removing large log files on Linux often leaves disk usage unchanged, reveals the hidden “ghost” processes that keep deleted files open, and provides step‑by‑step commands to identify, release, and prevent such space leaks.
Learn how to quickly locate oversized files and directories on a Linux server, verify safety before removal, use proper commands for secure deletion, and implement automation to prevent future disk‑space emergencies.
Learn how to efficiently locate and manage large files on Linux using powerful commands such as du, find, ls, and the visual tool ncdu, with step-by-step examples, sorting techniques, and practical tips for cleaning up disk space.
This article walks through troubleshooting a failed deployment caused by a full disk, showing how to use df -h to check overall disk usage and various du options (including --max-depth and -sh) to pinpoint large directories and resolve the issue.
This article explains how to handle MySQL disk‑space alerts by using the pt‑online‑schema‑change (pt‑osc) tool to selectively retain needed rows, migrate data to a temporary table, and drop the original table, thereby achieving fast, low‑impact data cleanup.
This guide explains how to verify disk alerts, locate large directories and files using df, du, and find commands, handle discrepancies caused by deleted files, and adjust system-reserved space to efficiently free up disk space on Linux servers.
When a Linux server triggers a disk‑space alert, you can pinpoint the offending directories or files by using df to view overall usage, du (with depth or max‑depth) or find to list large items, and lsof +L1 to detect deleted files still holding space, then optionally adjust reserved space with tune2fs.
This guide walks through a real‑world deployment issue where one node failed to start due to a full disk, showing how to verify overall and per‑directory disk usage with df and du commands, interpret their output, and locate large files or directories.
This guide explains how to diagnose and fix TiKV disk‑space problems by identifying oversized log files, redundant space‑placeholder files, and excessive RocksDB/Titan data, offering command‑line checks, configuration tweaks such as enabling log rotation, disabling reserve space, and tuning GC and Titan discardable‑ratio to restore balanced storage.
This guide explains why Elasticsearch throws cluster_block_exception, walks through diagnosing disk space, cluster health, node failures, read‑only settings, and index misconfigurations, and provides step‑by‑step commands and preventive measures to keep your cluster stable.
This article explains why disk space may not be freed after deleting large log files on a Linux server, describes the underlying file system mechanisms, and provides a step‑by‑step troubleshooting guide using /tmp cleanup and the lsof command to identify and kill lingering processes.
This guide explains practical commands like du, find, and lsof to locate large directories or deleted files consuming disk space, and shows how to adjust reserved filesystem space with tune2fs to reclaim lost capacity.
This guide explains how to use Linux commands like df, du, find, lsof, and tune2fs to locate large directories, uncover deleted files that still occupy space, and adjust reserved root space, enabling you to resolve unexpected disk‑usage alerts efficiently.
The article demonstrates that adding an explicit primary key to a MySQL InnoDB table can dramatically reduce its on‑disk size by eliminating the hidden clustered index, and explains how invisible primary keys can be used when schema changes are not possible.
This guide explains why Linux servers run out of memory or disk space, how to create and enable swap files, locate and remove large or numerous small files, use soft links to expand storage, and release space held by deleted files still opened by processes.
This guide explains why the /boot partition can fill up on Ubuntu, shows how to check its usage, safely remove old kernel and header packages, clean apt caches, and verify that space has been reclaimed for future updates.
This guide explains how to diagnose unexpected disk usage on Linux servers by using df to view overall usage, du and find to pinpoint large directories or files, and lsof to uncover deleted files that still hold space, plus how to adjust reserved space with tune2fs.
This article explains how to safely run MySQL's CLONE INSTANCE command with the DATA DIRECTORY option on a replica that lacks enough disk space for both source and target data sets, offering step‑by‑step strategies, SQL examples, and a final recommendation.
This article describes a step‑by‑step procedure for safely dropping a massive MySQL history_str table—including creating a new table, renaming, using hard links, staged drops, and a truncate script—to avoid instance hangs, replication lag, and I/O pressure while freeing disk space.
This guide explains how to locate large directories or files consuming disk space on Linux servers using commands like df, du, find, and lsof, and shows how to free space occupied by deleted files or adjust reserved root space with tune2fs.
This guide shows Linux administrators how to use df, du, find, lsof, and tune2fs commands to locate large directories, uncover hidden space consumed by deleted files, and adjust filesystem reserved space, with step‑by‑step examples and screenshots.
This article walks through a real‑world TiDB/TiKV disk‑space alarm case, diagnosing why the GC worker got stuck, how TiCDC’s lingering changefeed caused outdated MVCC versions, and the step‑by‑step commands and monitoring tricks used to restore normal GC and reclaim storage.
This article introduces pnpm, a fast and efficient JavaScript package manager that reduces disk usage by sharing dependencies, explains its core principles, highlights key features such as monorepo support and strict node_modules layout, and provides multiple installation methods for various operating systems.
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.
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.
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.
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 guide explains how to diagnose unexpected disk usage on Linux by using df, du, find, and lsof commands, demonstrates efficient ways to locate large directories or deleted files, and shows how to adjust reserved space with tune2fs to reclaim lost storage.
This guide explains how to use Linux commands such as df, du, find, and lsof to quickly locate directories, files, or deleted resources that are consuming disk space, and shows how to adjust reserved space with tune2fs to recover seemingly missing storage.
This article walks through diagnosing MySQL disk‑usage spikes caused by data fragmentation, explains why common cleanup commands may fail, and provides a detailed, repeatable procedure—including stopping the service, removing InnoDB files, and restoring the database—to finally free up the occupied space.
This article explains why MySQL 8.0 appears to lose about 1 GB of disk space when temporary tables are used, detailing the experiment, the role of TempTable, mmap allocation, and how performance_schema and procfs can be used to observe the process.
This article introduces pnpm, a fast and disk‑space‑efficient JavaScript package manager that improves on npm and Yarn, explains its core features such as speed, content‑addressable storage, monorepo support, and strict dependency management, and provides practical usage examples and security considerations.
When disk usage reported by df doesn't match du and inodes are not full, the discrepancy often stems from files that were deleted while still held open by running processes, and this guide explains how to identify those processes and safely free the space.
During a high‑traffic promotion a service ran out of disk space because massive log files weren't cleaned, the investigation revealed a lingering SLS process holding deleted files, and the article walks through the root‑cause analysis, the kill‑process fix, and a Spring‑Boot starter that dynamically degrades log levels to prevent recurrence.
This guide shows how to locate the hidden .PyCharm2019.3 folder on Windows, understand its purpose, and free up valuable C‑drive space by moving it to another drive and updating the corresponding paths in PyCharm’s idea.properties file, with step‑by‑step instructions and necessary code snippets.
This article explains how mistakenly using the == operator for Java object comparison, especially with enums and boxed types, can cause runtime failures after framework changes, and also shows how unchecked log growth can fill disks, degrade performance, and how to resolve both issues.
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.
When MySQL reports 100% disk usage with only a few megabytes left, typical fixes like dropping tables or restarting may not release space, so this article explains how to diagnose data_free bloat, apply proper fragmentation cleanup, and restore the database safely.
This guide explains why MySQL reports 100% disk usage despite minimal data, shows how to identify excessive data_free, details step‑by‑step commands to defragment tables, free space, and safely backup and restore the database.
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.
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 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.
This guide explains why removing a file with rm doesn't always release space, demonstrates creating a large test file, shows how open file handles keep space occupied, and provides commands to identify and release such hidden usage.
When a huge file is removed on a Linux server but the root partition still shows 100% usage, the issue is usually caused by the file being held open by a process, reserved filesystem space, or delayed space reclamation, and can be resolved with commands like lsof, kill, or tune2fs.
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.
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.
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.
The article investigates a MySQL crash caused by binlog errors due to a full '/' partition, explains why the error leads to server abort, demonstrates reproducing the issue with large transactions, traces the problem to the my_write function in the source code, and offers mitigation strategies such as reducing transaction size or expanding the temporary directory space.
The article investigates a sudden /tmp disk‑space explosion in a Flask‑based file transfer service, analyzes the Werkzeug form‑parsing code that creates temporary files for uploads larger than 500 KB, demonstrates reproducible tests with inotify and Python scripts, and offers practical recommendations to prevent similar failures.
This article explains why retrieving a MySQL table's on‑disk size via INFORMATION_SCHEMA.TABLES is unreliable, describes the impact of storage engines and row formats, and shows how to obtain accurate sizes by querying INNODB_SYS_TABLESPACES, including considerations for compression and configuration settings.
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.
A CentOS web server reports 100% disk usage despite du -sh /* showing far less space used, which is caused by Apache/Tomcat logs being cleared while the services are running, and the issue is resolved by restarting the services and properly cleaning old log files.
This article explains why deleted files can still occupy disk space on a Linux server, demonstrates how to identify them with lsof, and shows how configuring Filebeat’s close_older and force_close_files settings can automatically release the space.
This guide explains why Ethereum Wallet stores large blockchain data on the C: drive, the disk‑space issues it causes, and provides step‑by‑step Windows commands to create and remove hard links so the data can be moved to another location.
This guide explains why removing Apache/Tomcat log files while the services are running fails to release disk space, analyzes the inode‑locking behavior, and provides practical solutions such as restarting the server, truncating logs, and using scheduled cleanup commands.
A developer discovers a nearly full 1 TB server disk caused by large SQL Server backup files, learns the backup strategy, removes old backups while keeping monthly snapshots, manually syncs production data to a test server, and reflects on backup file formats and storage optimization.
A DBA intern recounts a real‑world Oracle tablespace failure, the challenges of resizing a BIGFILE tablespace, disk‑space shortages, permission errors during data‑file migration, and the key lessons about communication, analysis, and preparation for future production incidents.
This guide explains why Linux accumulates logs, caches, and temporary files, and provides step‑by‑step methods to reclaim disk space by safely removing old kernels, employing BleachBit for automated cleanup, and running e4defrag when fragmentation becomes a concern.
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.
