The mv command in Linux moves or renames files and directories. Its syntax is mv SOURCE… DEST, where DEST is either a filename (rename) or an existing directory (move).
By default it overwrites existing files without prompting; use -i (interactive), -n (no-clobber), -f (force), -u (update), or -v (verbose) to control behavior. If you’re new to Linux or managing servers, learning the mv command in Linux is essential for safe, efficient file operations.
In this guide, I’ll explain what mv does, how it differs when moving within or across filesystems, and how to use it with real world, production grade examples from simple renames to bulk moves.
What is the mv Command in Linux?
The mv (move) command relocates or renames files and directories. On the same filesystem, mv is an atomic operation that updates metadata instantly (using the rename system call).
Across filesystems, mv performs a copy then delete, which takes longer and may need permissions to preserve metadata. mv doesn’t duplicate data it moves it.
Basic mv Syntax
mv [OPTIONS] SOURCE DEST
mv [OPTIONS] SOURCE... DIRECTORYKey rules:
- If DEST is a file path, SOURCE must be a single file or directory (rename).
- If DEST is a directory, you can pass multiple SOURCE paths to move them inside DEST.
- mv overwrites DEST by default if a file with the same name exists (use -i or -n to stay safe).
Rename a File
mv report.txt report-2026].txtMove a File to a Directory
mv report-2026.txt ~/Documents/Move Multiple Files
mv *.log old-logs/Using globs like *.log depends on your shell. Always quote paths with spaces.
Essential mv Options (with Examples)
- -i (interactive): Prompt before overwrite.
- -n (no clobber): Never overwrite existing files.
- -f (force): Overwrite without prompting (default behavior; useful to override -i).
- -v (verbose): Show each move operation.
- -u (update): Move only if SOURCE is newer than DEST or DEST is missing.
- -t DIR (target directory, GNU): Specify the target directory first, handy with find/xargs.
- -b, –backup[=METHOD] (GNU): Make a backup of each existing destination file.
- –suffix=SUF (GNU): Set backup suffix (default is ~).
- -T (GNU): Treat DEST as a normal file (do not move into it if it’s a directory).
Interactive and Safe Moves
# Prompt before overwriting
mv -i app.conf /etc/myapp/
# Never overwrite
mv -n *.env backups/Verbose Output (Great for Scripts)
mv -v images/*.png public/img/Move Only Newer Files
# Move if source is newer (or dest doesn’t exist)
mv -u dist/* /var/www/html/Create Backups While Moving
# Keep a backup of overwritten files (e.g., file.conf becomes file.conf~)
mv -b *.conf /etc/myapp/
# Numbered backups: file.conf.~1~, file.conf.~2~, ...
mv --backup=numbered *.conf /etc/myapp/Safe Moving Strategies to Prevent Data Loss
- Use -i while learning; switch to -n for batch operations you don’t want overwritten.
- Combine -v for visibility, especially inside automation and CI/CD logs.
- Test globs with echo or ls before running mv: check what will match.
- For critical servers, snapshot or back up first. If you host with YouStable, leverage snapshot backups before large moves to reduce risk.
- Prefer same filesystem moves for large directories they’re instant and atomic.
Practical mv Examples for Daily Work
Move Files by Extension
# Move all JPEGs to img/
mkdir -p img
mv *.jpg *.jpeg img/ 2>/dev/nullThe 2>/dev/null suppresses “No such file or directory” if a glob doesn’t match in some shells.
Handle Filenames with Spaces
mv "Quarterly Report Q4.pdf" reports/Move a Directory Tree
Unlike cp, mv doesn’t need -r for directories. It moves whole directories by default.
mv staging_release/ releases/2026-01-09/On the same filesystem this is atomic a common zero downtime deployment trick when swapping release directories on web servers.
Rename Many Files with Brace Expansion
# Change extension from .htm to .html (loop for safety)
for f in *.htm; do
[ -e "$f" ] || continue
mv -v -- "$f" "${f%.*}.html"
doneMove Only Newer Build Artifacts
mv -u -v build/* /srv/app/current/Bulk Moves with find and xargs
When file lists are huge, globs may fail with “Argument list too long.” Use find with -exec or xargs.
# Move all .log files under logs/ into archive/
find logs -type f -name "*.log" -print0 | xargs -0 -I{} mv -v "{}" archive/
# GNU-friendly approach using -t:
find logs -type f -name "*.log" -exec mv -v -t archive/ {} +Move Across Filesystems (External Disk, Another Partition)
Cross filesystem moves copy then delete. This can take time and may alter metadata if you lack permissions. Use -v to track progress and -b/–backup to protect existing files.
mv -vb /data/media/* /mnt/external/media/Permissions, Ownership, and Timestamps
- Same filesystem: inode stays the same; permissions, ownership, and timestamps are preserved automatically.
- Across filesystems: mv attempts to preserve metadata. If you aren’t root and can’t preserve ownership, the destination owner may become your user (or the user running mv).
- SELinux/AppArmor contexts may be adjusted by policy in the destination directory.
On production servers, always verify permissions post move, especially under /etc, /var, or web roots like /var/www. A quick ls -l or namei -l helps confirm expected ownership.
mv vs cp vs rsync vs rename
- mv: Move or rename; atomic on same filesystem; no duplication of data.
- cp: Copy data; original remains; use -a to preserve attributes for directories.
- rsync: Robust copy/sync with retries, compression, partial transfers, and checksums ideal for remote or large sets.
- rename (Perl util/modern rename): Batch renaming using regex or rules; doesn’t move directories like mv.
Common mv Errors and How to Fix Them
- No such file or directory: Check spelling, quoting, and working directory (pwd).
- Permission denied: Use sudo, or fix ownership/permissions with chown/chmod.
- Not a directory: You passed a directory path where a file was expected, or vice versa. Verify DEST type.
- Cannot move ‘dir’ to a subdirectory of itself: You tried mv dir dir/subdir; choose a different destination.
- Argument list too long: Replace globs with find … -exec or xargs as shown above.
- Cross device link: On some systems rename across mounts fails; GNU mv handles this by copying ensure destination has enough space.
Best Practices for Servers and Production
- Deploy atomically: mv a prepared release directory into place on the same filesystem to minimize downtime.
- Log what you move: Use -v in scripts and pipe to logs for auditability.
- Protect configs: Use -i or –backup when touching /etc or live app folders.
- Pre-create destination directories with correct permissions (mkdir -p and chown/chmod) before moving.
- Backups first: On mission critical workloads, snapshot/backup before bulk moves. YouStable customers can use snapshot backups on VPS and dedicated servers to roll back in seconds.
FAQ’s
1. Does mv overwrite files? How can I prevent it?
Yes, mv overwrites existing files without asking. To prevent this, use -i to prompt before overwrite or -n to never overwrite. For extra safety, add -b or –backup to keep a backup of any overwritten destination file.
2. How do I move hidden files (dotfiles)?
Globs like * don’t match dotfiles by default. Use .??* to match hidden files with at least two characters, or enable dotglob in Bash: shopt -s dotglob; mv * target/. You can also explicitly list files, e.g., mv .env .gitignore target/.
3. What’s the difference between moving and renaming?
Both use mv. If DEST is a filename, mv renames the file. If DEST is a directory, mv relocates files into that directory. On the same filesystem, both actions are atomic; across filesystems, mv copies then removes the original.
4. How can I move files by pattern recursively?
Use find with -exec or xargs. Example: find . -type f -name “*.png” -exec mv -t images/ {} +. This avoids shell glob limits and reliably collects matches across subdirectories.
5. Can I undo mv if I made a mistake?
There’s no built in undo. Try moving it back if you know the original path. Otherwise, restore from backups or snapshots. On production systems hosted by providers like YouStable, snapshots make recovery fast enable them before risky operations.
Conclusion
The mv command in Linux is simple yet powerful. Master the core options (-i, -n, -v, -u, -t, -b), practice safe patterns for bulk operations, and leverage atomic moves for clean deployments. Whether you’re organizing files locally or shipping releases on a server, mv is a dependable, production ready tool.
