Take the 2-minute tour ×
Ask Ubuntu is a question and answer site for Ubuntu users and developers. It's 100% free, no registration required.

When copying files using cp, is it possible to display the progress and speed of the transfer? Otherwise, is there any alternative command line utility that can achieve this?

share|improve this question

11 Answers 11

up vote 61 down vote accepted

While cp hasn't got this functionality, you can use pv to do this:

pv my_big_file > backup/my_big_file

Note: this method will lose the file's permissions and ownership. Files copied this way will have the same permissions as if you'd created them yourself and will belong to you.

In this example, pv basically just outputs the file to stdout*, which you redirect to a file using the > operator. Simultaniously, it prints information about the progress to the terminal when you do that.

This is what it looks like:

stefano@ubuntu:~/Data$ pv my_big_file > backup/my_big_file
 138MB 0:00:01 [73.3MB/s] [=================================>] 100% 

You may need to  Install pv (alternatively, type sudo apt-get install pv) on your system.


*: The technical bit

There are three important streams of data in a unix-like system: stdout (standard output), stderr (standard error) and stdin (standard input). Every program has all three, so to speak. The pipe-operator redirects a programs output to another programs input. The > operator redirects a programs standard output to a file. cp basically does nothing fancier than

cat source > destination

(where cat just reads a file and prints it to stdout). pv is just like cat, but if you redirect it's output stream somewhere else, it will print progress information to stdout instead.

Take a look at man pv to learn more about it.


Another option, as alt textDoR suggests in this answer, is to use rsync instead:

rsync -ah --progress source-file destination

alt text

This will preserve the files permissions/ownership while showing progress.

share|improve this answer
2  
It may or may no be significant (depending on the situation), but pv does not handle permissions the same way as cp does... (based on one quick test I tried: pv didn't copy the execute bit across.. rsync did. –  Peter.O Dec 14 '10 at 15:55
    
Thanks for reminding me fred.beak, I didn't think to put that in. –  Stefano Palazzo Dec 14 '10 at 18:53
12  
IMO: alias cp="rsync -avz" cp is outdated. –  Marco Ceppi Dec 26 '10 at 1:26
3  
If you're like me, and forget about pv, you can go snooping in /proc/PID of cp/fd and /proc/PID of cp/fdinfo to figure out progress. (It's up to you to infer speed.) I use this technique to watch updatedb. –  Thanatos Dec 26 '10 at 1:30
    
for a man of pv without installing it see here –  Walter Tross Nov 16 '12 at 13:45

If you want to see if your files are transferring correctly you could use gcp and gcp is like cp but by default gives you a progress bar so that you can see what is being copied. As the program's wiki notes, gcp has several useful features such as

  • transfer progression indication
  • continuous copying on error (skip to next file)
  • copy status logging: gcp logs all its actions so that it is possible to know which files have been successfully copied
  • name mangling to handle target filesystem limitations (for example deletion of incompatible characters "*" or "?" on FAT)

However, even when the progress bar has reached 100% when using the tool, you must wait until your terminal prompt reappears before safely removing your media so that you can ensure that the transfer process has successfully finished.

gcp is used to copy files and has options such as --preserve so that various attributes and permissions can be preserved and --recursive so that whole directories can be copied. More information on its options can be found by entering man gcp or by going to the Ubuntu manpages online. A tutorial is also available on this site.

Install gcp from the repositories with

sudo apt-get install gcp

(Note: in Ubuntu 12.10 the new automount point is, for example, /media/user/usbdisk)

You can copy a file to your media by entering

gcp /home/mike/file.mp4 /media/usb

and copy a folder to your media with

gcp -rv ~/Podcasts /media/Mik2

Sample output from gcp with the progress bar:

gcp ~/Videos_incIplayer/mars.flv /media/Mik2
Copying 168.57 MiB 100% |########################################################|   7.98 M/s Time: 00:00:22

You can of course specify multiple files or folders to copy to your disk, and there are a lot of other options covered in man gcp.

share|improve this answer

There isn't. See here as to why. Although it does more than you need, rsync has one with --progress parameter. The -a will keep permissions,etc, and -h will be human readable.

rsync -ah --progress source destination
share|improve this answer

While it doesn't display speed, when copying multiple files, the -v option to the cp command will provide you with progress info. e.g.

cp -rv old-directory new-directory
share|improve this answer
    
Your idea made perfect sense to me. I am copying several files from an old CD-ROM and I just want to make sure it isn't stuck trying to read a corrupted file. Printing the files that have been successfully read solved my problem. –  Lucio Paiva Nov 21 at 14:46

I get a kick out of using cURL for this exact purpose. The man page lists the "FILE" protocol as supported, so just use it like any other protocol in a URL:

curl -o destination FILE://source

Speed, progress, time remaining, and more -- all in a familiar format.

share|improve this answer
    
This is great especially in environments where you are prohibited from installing new tools and where rsync is unavailable. –  rr- Sep 5 '13 at 7:00

The kernel knows most of the data, like speed, and often also percentage. Modern kernels expose this via their /proc filesystem.

showspeed from https://github.com/jnweiger/showspeed uses that info. It can attach to already running programs, and give periodict updates like this:

$ dd if=bigfile of=/tmp/otherbigfile &
$ showspeed dd
dd looks like a process name. pid=4417 matches av0=dd.
p/4417/fd/0r /home/jw/bigfile 113MB/s (12%, 2.3GB)  9m:35
p/4417/fd/1w /tmp/otherbigfile 182MB/s (2.6GB)
p/4417/fd/0r /home/jw/bigfile 285MB/s (15%, 3.0GB)  8m:08
p/4417/fd/0r /home/jw/bigfile 115MB/s (16%, 3.2GB)  8m:01
p/4417/fd/0r /home/jw/bigfile 107MB/s (17%, 3.4GB)  7m:39
p/4417/fd/1w /tmp/otherbigfile 104MB/s (3.5GB)
p/4417/fd/0r /home/jw/bigfile 139MB/s (19%, 3.7GB)  7m:37
p/4417/fd/0r /home/jw/bigfile 116MB/s (20%, 3.9GB)  7m:18
p/4417/fd/1w /tmp/otherbigfile  67MB/s (4.0GB)
p/4417/fd/1w /tmp/otherbigfile 100MB/s (4.1GB)
...
share|improve this answer
    
Nice one. How does it work out percentages though? I guess only in case of file s open as read only? And it will probably not work in case of scattered access. –  j_kubik 11 hours ago

While pv can deal with local cp tasks, using dd with pv can deal with both local (cp) and remote (scp) tasks.

dd if=path/to/source.mkv | pv | dd of=path/to/dest.mkv

Please ensure the path/to/dest.mkv exits by touch path/to/dest.mkv

This can show the progress, but if you want the percentage information,

dd if=path/to/source.mkv | pv -s 100M | dd of=path/to/dest.mkv

Replace 100M above with the real size of your source file.

Here Comes the Remote Part

While scp can hardly show current progress, using dd with pv is a piece of cake.

ssh onemach@myotherhost dd if=path/to/source.mkv | pv -s 100M | dd of=path/to/dest.mkv

share|improve this answer

There's a new tool called cv that can find any descriptor related to a running command and show progress and speed: https://github.com/Xfennec/cv

cv -w

outputs the stats for all running cp,mv etc. operations

share|improve this answer

As many said, cp does not include this functionality.

Just to throw my $0.02, what I usually do with trivial copying situations (i.e. no -R):

  1. See how big the file is and remember

  2. Start copying

  3. Open another terminal

  4. Run watch ls -lh DIR on the directory where the target is

This can keep me updated on target file size, with quite a minimum hassle.

As an alternative for less trivial situations, e.g. recursively copying directories, you can use watch du -hs DIR to see summary of DIR size. However du can take long to compute and can even slow down the copying, so you might want to use -n INTERVAL argument to watch so that trade-off is acceptable.

Update: In case you use wild-cards with command used with watch du, e.g. watch du -hs backup/*, don't forget to quote:

watch "du -hs backup/*"

otherwise the wild-cards will be expanded only once, when watch is started so du will not look at new files / subdirectories.

share|improve this answer
    
Does not answer the "speed" part, though... –  Alois Mahdal Nov 16 '12 at 13:21

Use a shell script:

#!/bin/sh
cp_p()
{
   strace -q -ewrite cp -- "${1}" "${2}" 2>&1 \
      | awk '{
        count += $NF
            if (count % 10 == 0) {
               percent = count / total_size * 100
               printf "%3d%% [", percent
               for (i=0;i<=percent;i++)
                  printf "="
               printf ">"
               for (i=percent;i<100;i++)
                  printf " "
               printf "]\r"
            }
         }
         END { print "" }' total_size=$(stat -c '%s' "${1}") count=0
}

This will look like:

% cp_p /home/echox/foo.dat /home/echox/bar.dat
66% [===============================>                      ]

Source

share|improve this answer


gcp is an advanced command line file copier that is inspired by the standard cp command but provides various advanced features like progress bar indicator, source lists, continuous copying even if there is a problematic file etc.

just install and use: sudo apt-get install gcp Here is a complete list of options : gcp --help

Usage: 
        gcp [options] FILE DEST
        gcp [options] FILE1 [FILE2 ...] DEST-DIR

        gcp --help for options list


Options:
  --version             show program's version number and exit
  -h, --help            show this help message and exit
  -r, --recursive       copy directories recursively
  -f, --force           force overwriting of existing files
  --preserve=PRESERVE   preserve  the  specified  attributes
  -L, --dereference     always follow symbolic links in sources
  -P, --no-dereference  never follow symbolic links in sources
  --no-fs-fix           don't fix filesystem name incompatibily
  --no-progress         deactivate progress bar
  -v, --verbose         Show what is currently done

  sources saving:
    --sources-save=SOURCES_SAVE
                        Save source arguments
    --sources-replace=SOURCES_REPLACE
                        Save source arguments and replace memory if it already
                        exists
    --sources-load=SOURCES_LOAD
                        Load source arguments
    --sources-del=SOURCES_DEL
                        delete saved sources
    --sources-list      List names of saved sources
    --sources-full-list
                        List names of saved sources and files in it

gcp command is almost "the same", don't need to learn/remember anything new.

share|improve this answer

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.