df

What it does

df (disk free) reports how much space is used and available on each mounted filesystem, as the kernel accounts for it. Run with no arguments, it lists every currently mounted filesystem; given a file or directory path, it reports only the filesystem that path lives on. It's the go-to command for answering "am I about to run out of disk space?" at the filesystem level, as opposed to du, which answers "which files or directories are using the space?"

Beginner examples

• df — list all mounted filesystems with raw block counts
• df -h — same, but with human-readable sizes like 12G or 340M
• df -h / — check usage on just the root filesystem
• df -h /home — check usage on whichever filesystem /home is mounted on
• df -T — add a column showing each filesystem's type (ext4, xfs, tmpfs, etc.)

df -h

Advanced examples

• Show type and human-readable sizes together: df -hT
• Check inode usage instead of block usage: df -i
• Exclude noisy pseudo-filesystems like tmpfs and devtmpfs: df -h -x tmpfs -x devtmpfs
• Limit output to a specific filesystem type: df -h -t ext4
• Combine with awk to alert when usage crosses a threshold: df -h --output=pcent,target | awk 'NR>1 && $1+0 > 90'

df -hT | grep -v tmpfs

Common mistakes

• Confusing df with du — df reports whole-filesystem usage, du reports usage of specific files/directories; they can disagree, especially when a deleted file is still held open by a process (df counts it, du can't see it).
• Reading raw block counts instead of adding -h, making sizes hard to interpret at a glance.
• Assuming free space means you can create more files — if inodes are exhausted (df -i shows 100%), you'll get "No space left on device" even with free bytes available.
• Forgetting that bind mounts and network filesystems (NFS, tmpfs) show up in plain df output and can clutter results — use -x to exclude types you don't care about.

Tips

• Use df -h as a first check whenever a process fails with a disk-space-related error.
• Pair df -i with df -h when debugging "no space left" errors on filesystems full of tiny files (e.g. mail queues, session caches) — inode exhaustion looks identical to space exhaustion from the application's point of view.
• df -hT is a good habit for quickly seeing whether a mount is the type you expect (e.g. confirming a volume mounted as ext4 rather than falling back to tmpfs).
• Script periodic checks with df --output=pcent,target for clean, parseable output.

Best practices

• Monitor df -h output for critical mount points (/, /var, /home) as part of routine system health checks or alerting.
• Check both block usage (df -h) and inode usage (df -i) when diagnosing "disk full" symptoms — they're independent resources.
• Exclude ephemeral pseudo-filesystems (tmpfs, proc, sysfs) from usage reports to avoid false alarms in monitoring scripts.
• Use a specific path argument (df -h /var/log) rather than parsing the full listing when you only care about one mount.

Real-world use cases

• Diagnosing why a deployment or database failed with a disk-space error.
• Setting up a monitoring alert that pages when any filesystem exceeds 90% usage.
• Verifying a newly attached volume mounted correctly and with the expected filesystem type before writing data to it.
• Investigating "No space left on device" errors that turn out to be inode exhaustion rather than block exhaustion.

Common interview questions

• What's the difference between df and du? df reports space usage per mounted filesystem as tracked by the kernel; du reports space used by specific files or directories you point it at by walking the directory tree.
• Why might df show a filesystem as full even after you delete files? If a process still has the deleted file open, the kernel doesn't reclaim the space until the file handle is closed, so df continues to count it as used.
• How do you check for inode exhaustion? Run df -i, which reports inode usage and availability instead of block usage — a filesystem can be 100% full on inodes while still showing free space in blocks.
• How would you find which mount point a given directory belongs to? Run df on that path, e.g. df -h /var/log/myapp, and df resolves it to the underlying mounted filesystem.