Linux Find Command Examples for Cleaning Up Large Files

Pick the right linux find command

Before running cleanup commands, verify your working directory and permissions. The find utility operates on the current directory by default, so it is easy to accidentally scan your entire home folder or system root if you do not specify a starting point. Always double-check your location with pwd and use absolute paths when targeting specific directories.

You also need to understand the difference between file size and directory size. The find command with the -size flag measures the actual file size, ignoring the disk blocks allocated to directories. If you need to see which folders are consuming the most space, you should use du instead. Mixing these tools can lead to incomplete cleanup results.

Finally, consider the scope of your search. Large files are often scattered across different subdirectories. A broad search like find / -type f -size +100M can take a long time and may hit permission errors on system directories. It is usually better to start with a specific path, such as /var/log or your home directory, to keep the operation fast and safe.

Run linux find command safely

Cleaning up large files is a routine maintenance task, but running deletion commands blindly can lead to data loss. The find command is powerful because it filters files before you ever touch a deletion utility. By combining find with safe preview flags, you can verify exactly what will be removed. This section walks through the safest way to execute the linux find command for cleanup, ensuring you only delete what you intend to.

1. Preview large files without deleting

Before removing anything, list the files to understand the scope of the cleanup. Use the -size flag to filter for files larger than a specific threshold. For example, to find all files larger than 100 megabytes in the current directory and its subdirectories, run:

find . -type f -size +100M

This command returns a list of file paths. It is read-only and safe. You can adjust the size suffix (M for megabytes, G for gigabytes, k for kilobytes) to match your needs. Reviewing this list helps you identify temporary files, old logs, or large downloads that are safe to remove.

2. Add human-readable output

A raw list of paths can be hard to parse if there are thousands of results. Adding the -exec ls -lh {} \; option appends detailed information to each file, including size, permissions, and modification date. This helps you prioritize which files to delete based on recency and size:

find . -type f -size +100M -exec ls -lh {} \;

This approach gives you a full report. You can spot large, old files that are likely candidates for deletion. It prevents accidental removal of recently modified files that might still be in use. The ls -lh output makes it easy to scan the list visually.

3. Test with a dry-run delete

Once you have identified the files, test the deletion logic without actually removing data. Use the -delete action in combination with a safe flag, or simply pipe the output to echo to see what would happen. A safer test is to use find with -print to confirm the exact set of files:

find . -type f -size +100M -print

If you want to simulate deletion, you can use xargs with echo rm:

find . -type f -size +100M -print0 | xargs -0 echo rm

This prints the rm commands to the terminal. If the list looks correct, you can remove echo to execute the actual deletion. This step acts as a final safety check before permanent changes.

4. Execute the deletion

When you are confident in the list, run the actual deletion command. Use -delete for simplicity, or xargs rm for more control over the process. For large numbers of files, xargs is more efficient because it batches the deletion calls:

find . -type f -size +100M -delete

Or using xargs:

find . -type f -size +100M -print0 | xargs -0 rm

The -print0 and -0 flags handle filenames with spaces or special characters safely. This ensures that the command works correctly even with unusual file names. Always run this command from the correct directory to avoid deleting files in the wrong location.

5. Verify the cleanup

After deletion, verify that the files are gone and that disk space has been freed. Use du -sh . to check the total size of the current directory. Compare this with the size before deletion to confirm the cleanup was successful. You can also re-run the preview command from step 1 to ensure no large files remain:

find . -type f -size +100M

If the output is empty, the cleanup is complete. If files remain, they may be in use by the system or locked by processes. In such cases, you may need to stop the service or wait for a reboot before deletion.

Safety checklist

Mistakes That Break the Result

Even simple find commands can go wrong if you don't account for how the system handles permissions, symlinks, or large numbers of files. These errors don't just fail silently; they can delete the wrong data, miss the largest offenders, or hang your terminal. Here are the most common pitfalls and how to avoid them.

Ignoring Permission Denied Errors

By default, find will print "Permission denied" for every directory or file it cannot read. In a large filesystem, this spam can make it hard to see actual errors or results. You can suppress these messages by redirecting standard error to /dev/null:

find /path -type f -size +100M 2>/dev/null

This keeps your output clean. However, be aware that you are also hiding real errors. If the command fails to find anything, it might be because you lack permissions, not because the files don't exist. Always check your user privileges first.

Following Symlinks Unintentionally

If you use -L to follow symbolic links, find may traverse into directories you didn't intend to search, potentially leading to infinite loops or deleting files in unexpected locations. For cleaning up large files, you usually want to stick to the physical files. Avoid -L unless you specifically need to resolve where a symlink points. Instead, use -type l to find symlinks themselves if you want to clean up broken references.

Overloading the Command Line

When dealing with millions of files, passing all results to xargs or a custom action can exceed the system's argument length limit. This causes a "Argument list too long" error. To prevent this, always pipe through xargs with care, or use find's built-in -exec with a trailing + instead of ;. The + variant batches arguments efficiently:

find /path -type f -size +1G -exec rm {} +

This is safer and faster than -exec rm {} \; because it runs the command only once per batch of files, rather than once per file.

Confusing Block Size Units

The -size option can be tricky. -size +100M means strictly greater than 100 megabytes. If you use -size +100c, it counts bytes. A common mistake is using -size +100 without a suffix, which defaults to 512-byte blocks. This means you are looking for files larger than 50KB, not 100KB. Always specify the unit (c for bytes, k for kilobytes, M for megabytes, G for gigabytes) to be precise.

Linux find command questions

Even with a clear strategy, the find command can raise practical concerns about safety and precision. These answers address the most common objections before you run cleanup commands.

Build the routine

1

Pick the main use

Start with the job this has to do most often, then ignore features that do not help with that.

2

Choose the simplest setup

Favor the option that is easy to repeat on a busy day.

3

Make cleanup obvious

Store the tool and cleaning supplies where you will actually use them.

Previous

123

Next