How To Copy Directory In Linux : Linux Folder Copying Commands

by

Organizing your project files often requires creating a duplicate of a folder structure to maintain consistency. If you are wondering how to copy directory in linux, the process is straightforward once you understand a few key commands. This guide walks you through every method, from basic copies to advanced options, ensuring you never lose a file again.

Copying directories in Linux is a daily task for developers and system administrators. Unlike copying a single file, directories require special flags to include their contents. The most common tool is the cp command, but there are other powerful utilities like rsync and tar that offer more control.

In this article, you will learn the exact syntax, practical examples, and common pitfalls. By the end, you will confidently duplicate folders, preserve permissions, and even copy over networks. Let’s start with the basics and build up to advanced techniques.

How To Copy Directory In Linux

The core command for copying directories is cp with the -r (recursive) flag. Without this flag, cp will refuse to copy a directory and throw an error. The basic syntax is:

cp -r source_directory destination_directory

For example, to copy a folder named project to a backup location:

cp -r project /backups/project_copy

This creates an exact replica of project inside /backups. If the destination already exists, the source directory is placed inside it. If the destination does not exist, it is created as a new folder with the source’s contents.

One common mistake is forgetting the -r flag. Without it, you will see an error like cp: omitting directory 'project'. Always double-check your command before running it, especially when working with large directories.

Using The Cp Command With Different Options

The cp command offers several flags to customize the copy behavior. Here are the most useful ones:

  • -r or --recursive: Required for copying directories. It copies the folder and all its contents recursively.
  • -a or --archive: Preserves permissions, ownership, timestamps, and copies recursively. This is the best option for creating a perfect backup.
  • -v or --verbose: Shows each file as it is copied. Helpful for monitoring progress.
  • -i or --interactive: Prompts before overwriting existing files. Prevents accidental data loss.
  • -u or --update: Copies only when the source file is newer than the destination file or when the destination is missing.
  • -n or --no-clobber: Does not overwrite existing files. Useful for avoiding accidental replacements.

For instance, to copy a directory with full preservation and verbose output:

cp -av project /backups/project_archive

This command will list every file being copied while keeping all metadata intact. It is ideal for migrating projects between systems.

Another practical example is using the interactive flag to avoid overwriting important files:

cp -ri project /backups/project

If a file with the same name exists in the destination, you will be asked to confirm before it is replaced. This adds a safety net for critical operations.

Copying Directories With Rsync

rsync is a powerful tool for copying and synchronizing directories. It is faster than cp for large transfers because it only copies differences. The basic syntax for copying a directory locally is:

rsync -av source_directory/ destination_directory/

Note the trailing slashes. A trailing slash on the source means “copy the contents of the directory,” while omitting it copies the directory itself. For example:

  • rsync -av project/ /backups/project/ copies the contents of project into /backups/project.
  • rsync -av project /backups/ copies the project folder itself into /backups.

The -a flag stands for archive mode, which preserves permissions, timestamps, and other attributes. The -v flag enables verbose output. You can also use --progress to see transfer progress:

rsync -av --progress project/ /backups/project/

rsync is especially useful for incremental backups. If you run the same command again, it will only copy new or changed files, saving time and bandwidth. It also works over SSH for remote copying:

rsync -avz project/ user@remote_host:/backups/project/

The -z flag compresses data during transfer, which speeds up copying over slow networks. This makes rsync the go-to tool for syncing directories across machines.

Copying Directories Using Tar And Pipe

Another method involves using tar to archive a directory and pipe it to another location. This is useful when you need to copy a directory with specific file exclusions or when you want to combine multiple operations. The command looks like this:

tar cf - source_directory | tar xf - -C destination_directory

Let’s break it down. The first tar cf - creates an archive of the source directory and sends it to standard output (the dash - means stdout). The pipe | sends that data to the second tar xf -, which extracts the archive in the destination directory specified by -C.

For example, to copy project into /backups:

tar cf - project | tar xf - -C /backups

This method preserves permissions and timestamps by default. You can also exclude files using the --exclude option:

tar cf - --exclude='*.log' project | tar xf - -C /backups

This copies the entire directory except files ending in .log. The tar pipe method is efficient because it avoids creating an intermediate archive file on disk.

One downside is that it does not show progress by default. You can add the -v flag to both tar commands for verbose output, but that can clutter the terminal for large directories.

Copying Directories With Ssh And Scp

For remote copying, scp (secure copy) is a simple tool that uses SSH. The syntax is similar to cp but includes a remote path:

scp -r source_directory user@remote_host:destination_path

For example, to copy a local directory to a remote server:

scp -r project user@192.168.1.100:/home/user/backups/

The -r flag is required for directories, just like with cp. You can also copy from a remote machine to your local system:

scp -r user@remote_host:/home/user/project /local/backups/

scp is straightforward but lacks features like incremental copying or compression. For those, use rsync over SSH instead. However, scp is widely available and works out of the box on most systems.

One tip: if you copy large directories over a slow connection, consider compressing them first with tar and then transferring the archive. This reduces transfer time significantly.

Preserving File Permissions And Ownership

When copying directories, you often want to keep the original permissions and ownership. The cp -a flag does this automatically. It is equivalent to cp -dR --preserve=all. For example:

cp -a project /backups/project_backup

This preserves symbolic links, permissions, timestamps, and ownership. However, note that only root can preserve ownership. If you copy as a regular user, ownership will change to your user.

With rsync, the -a flag also preserves these attributes. For remote copies, you may need to use --rsync-path="sudo rsync" on the remote machine to preserve ownership if you have sudo access.

If you only need to preserve permissions but not ownership, use cp -p or rsync -p. The -p flag preserves the original timestamps and permissions.

Handling Symbolic Links And Hard Links

Symbolic links (symlinks) require special attention during directory copies. By default, cp -r copies symlinks as symlinks. If you want to copy the files they point to instead, use the -L flag:

cp -rL project /backups/project

This dereferences symlinks and copies the actual files. The -P flag (default) preserves symlinks. For rsync, the -l flag preserves symlinks, while -L dereferences them.

Hard links are handled differently. With cp -a, hard links are preserved as hard links in the destination. If you want to copy the actual file contents and break the links, use cp -r --preserve=links or simply copy without special flags.

To check if a file is a symlink, use ls -l. Symlinks show an arrow pointing to the target file. Hard links are indistinguishable from regular files except by their inode number.

Common Errors And Troubleshooting

Even experienced users encounter errors when copying directories. Here are the most common ones and how to fix them:

  • “cp: omitting directory”: You forgot the -r flag. Add it and try again.
  • “Permission denied”: You do not have read access to the source or write access to the destination. Use sudo or change permissions with chmod.
  • “No space left on device”: The destination disk is full. Free up space or choose a different location.
  • “rsync: failed to set permissions”: You are not root and trying to preserve ownership. Use --no-owner and --no-group flags.
  • “scp: not a regular file”: You forgot the -r flag for remote copies.

If a copy fails partway through, you can resume it with rsync by running the same command again. It will only copy missing or changed files.

Another common issue is copying to a destination that already contains files. Use the -n flag with cp or --ignore-existing with rsync to avoid overwriting.

Copying Directories With Exclusions

Sometimes you want to copy a directory but skip certain files or subdirectories. The rsync command excels at this with the --exclude option. For example, to copy a project directory while ignoring node_modules and .git folders:

rsync -av --exclude='node_modules' --exclude='.git' project/ /backups/project/

You can also use a pattern file with --exclude-from:

rsync -av --exclude-from=exclude_list.txt project/ /backups/project/

The exclude_list.txt file contains one pattern per line, such as *.log or temp/. This is useful for complex exclusion rules.

With cp, exclusions are not directly supported. You would need to use find combined with cp or use tar with the --exclude option as shown earlier.

Copying Large Directories Efficiently

For large directories (gigabytes or terabytes), performance matters. Here are tips to speed up the process:

  • Use rsync instead of cp: It only transfers differences, so subsequent copies are fast.
  • Compress data on the fly: Use rsync -z or tar with compression (e.g., tar czf -).
  • Increase I/O priority: Use ionice to give the copy process higher disk priority.
  • Copy to a different disk: Avoid copying within the same physical disk to reduce seek times.
  • Use parallel processes: Tools like parallel can copy multiple files simultaneously, but this is advanced.

For example, to copy a large directory with compression and progress:

rsync -avz --progress project/ user@remote:/backups/

This compresses data during transfer and shows a progress bar for each file. It is ideal for slow network connections.

Frequently Asked Questions

1. What is the difference between cp -r and cp -a?
cp -r copies directories recursively but does not preserve all attributes. cp -a (archive mode) preserves permissions, timestamps, ownership, and symbolic links. Use -a for backups and -r for simple copies.

2. How do I copy a directory without overwriting existing files?
Use cp -n (no-clobber) or rsync --ignore-existing. These flags prevent any existing files from being replaced.

3. Can I copy a directory to multiple destinations at once?
Not directly with a single command. You can use a loop in bash: for dest in /path1 /path2; do cp -r source "$dest"; done.

4. Why does rsync copy hidden files but cp does not?
Both copy hidden files (those starting with a dot) by default. However, if you use a wildcard like cp -r project/* /dest, hidden files are excluded because the shell does not expand * to include dot files. Use cp -r project/. /dest to include them.

5. How do I copy a directory and maintain the same file system structure?
Use cp -a or rsync -a with the exact source and destination paths. Both preserve the directory tree and metadata. For remote copies, rsync -av works best.

Final Tips For Copying Directories

Always test your copy command on a small directory first. Use the --dry-run option with rsync to see what would happen without actually copying:

rsync -av --dry-run project/ /backups/

This prints a list of files that would be transferred. It is a safe way to verify your command before executing it.

Another best practice is to use absolute paths for both source and destination. This avoids confusion when running commands from different directories. For example, use /home/user/project instead of just project