Ask Ubuntu is a question and answer site for Ubuntu users and developers. Join them; it only takes a minute:

Sign up
Here's how it works:
  1. Anybody can ask a question
  2. Anybody can answer
  3. The best answers are voted up and rise to the top

dd is a wonder allowing you to duplicate a hard drive to another, completely zero a hard drive, etc. But once you launch a dd command, there's nothing to tell you of it's progress. It just sits there at the cursor until the command finally finishes. So how does one monitor dd's progress?

share|improve this question
@mwfearnley Just to be clear, it's status=progress, not the other way around. – Ryan Pendleton Jul 20 at 13:36
Doh! Resubmitting my comment. Ahem... – mwfearnley Jul 20 at 13:57
As of Ubuntu 16.04, this is now solved in dd itself with a new status=progress parameter, as described in phoibos's answer below. – mwfearnley Jul 20 at 13:57
I think phoibos' answer is the most appropriate here for the accepted answer. – Masi Jul 20 at 17:52

15 Answers 15

Update 2016: If you use GNU coreutils >= 8.24 (default in Ubuntu Xenial 16.04 upwards), see method 2 below for an alternate way to display the progress.

Method 1: By using pv

Install pv and put it between input / output only dd commands.

Note: you cannot use it when you already started dd.

From the package description:

pv - Pipe Viewer - is a terminal-based tool for monitoring the progress of data through a pipeline. It can be inserted into any normal pipeline between two processes to give a visual indication of how quickly data is passing through, how long it has taken, how near to completion it is, and an estimate of how long it will be until completion.


sudo apt-get install pv


dd if=/dev/urandom | pv | dd of=/dev/null


1,74MB 0:00:09 [ 198kB/s] [      <=>                               ]

You could specify the approximate size with the --size if you want a time estimation.

Example Assuming a 2GB disk being copied from /dev/sdb

Command without pv would be:

sudo dd if=/dev/sdb of=DriveCopy1.dd bs=4096

Command with pv:

sudo dd if=/dev/sdb | pv -s 2G | dd of=DriveCopy1.dd bs=4096


440MB 0:00:38 [11.6MB/s] [======>                             ] 21% ETA 0:02:19

Other uses

You can of course use pv directly to pipe the output to stdout:

pv /home/user/bigfile.iso | md5sum


50,2MB 0:00:06 [8,66MB/s] [=======>         ] 49% ETA 0:00:06

Note that in this case, pv recognizes the size automatically.

Method 2: New status option added to dd (GNU Coreutils 8.24+)

dd in GNU Coreutils 8.24+ (Ubuntu 16.04 and newer) got a new status option to display the progress:


dd if=/dev/urandom of=/dev/null status=progress


462858752 bytes (463 MB, 441 MiB) copied, 38 s, 12,2 MB/s
share|improve this answer
pv bigfile.iso | dd of=/dev/yourdevice – Ion Br. Dec 17 '13 at 21:02
Note that the parameters for "dd" are appropriate in the first half (the input part of the pipe): dd if=/dev/zero bs=1M count=35000 | pv | dd of=VirtualDisk.raw. – Sopalajo de Arrierez Mar 28 '14 at 0:05
pv bigfile.iso | dd of=VirtualDisk.raw bs=1M count=35000 works, verified. @SopalajodeArrierez, parameters can be given in the second dd. – SiddharthaRT Oct 20 '14 at 12:17
using pv < /dev/sda > /dev/sdb seems to get better speed (source) – Nicola Feltrin Feb 20 '15 at 13:30
FYI on speed. Tests on my computer with Samsung 840 PRO SSD: dd if=/dev/urandom | pv | of=/dev/sdb gives ~18MB/s write, dd if=/dev/zero | pv | of=/dev/sdb gives ~80MB/s, and plain old dd if=/dev/zero of=/dev/sdb gives ~550MB/s (close to SSD max write speed). All with bs=4096000. – Tedd Hansen May 7 at 21:18
up vote 239 down vote accepted

From HowTo: Monitor the progress of dd

You can monitor the progress of dd without halting it by using the kill command.

To see the progress of dd once it's running, open another terminal and enter:

sudo kill -USR1 $(pgrep ^dd)

This will display dd progress in the dd terminal window without halting the process. If you're on BSD or OS X, use INFO instead of USR1. The USR1 signal will terminate dd.

If you would like to get regular updates of the dd progress, then enter:

watch -n5 'sudo kill -USR1 $(pgrep ^dd)'

watch will probe the dd process every -n seconds (-n5 = 5 seconds) and report without halting it.

Note the proper single quotes in the commands above.

share|improve this answer
This worked, but a couple of comments. First of all, I'm not sure why you escaped your backticks (if it's for the SO editor, you did it incorrectly). Secondly I'd recommend using ^dd$, just in case something else is running with the prefix dd. Finally, you don't need sudo to send the USR1 signal. Otherwise, good answer, +1. – gsingh2011 Jul 14 '13 at 20:25
@gsingh2011 For a description of why sudo is used and each command is placed as it is, read the article it's from (linked at the top of the answer) – James Jul 17 '13 at 23:17
NB! This way interupts dd work under OSX. – Speakus Nov 17 '14 at 6:33
@Speakus You have to use kill -INFO $(pgrep ^dd$) on BSD systems (like OSX). – Torben Jun 6 '15 at 8:22
sudo pkill -usr1 dd is easier to remember, works perfectly fine (at least on Ubuntu 14.04), and is less to type. – Phizes Sep 7 '15 at 12:59

A few handy sample usages with pv and less typing or more progress then other answers:

First you will need to install pv, with the command:

sudo apt-get install pv

Then some examples are:

pv -n /dev/urandom | dd of=/dev/null
pv -tpreb source.iso | dd of=/dev/BLABLA bs=4096 conv=notrunc,noerror

Note: the first sample is 5 characters less typing then dd if=/dev/urandom | pv | dd of=/dev/null.

And my favorite for cloning a disk drive:

(pv -n /dev/sda | dd of=/dev/sdb bs=128M conv=notrunc,noerror) 2>&1 | dialog --gauge "Running dd command (cloning), please wait..." 10 70 0


Also for archiving myself.

share|improve this answer
@probackup those edits are not really helpful - the bold adds nothing to the answer, in fact it makes it hard to read. – Tim Aug 29 '14 at 21:56
you will need to install also dialog with the command apt-get install dialog – k7k0 Apr 29 '15 at 19:06
LOVE the dialog example. SERENITY NOW! – alex gray Nov 22 '15 at 20:47
Can you only call that dialog with python? – mikeymop Apr 29 at 19:50
Calling from python? You may use it with "subprocess.Popoen". Despite not recommended because of security issues. Without graphicish results, this guy has made a similar impact: Check out I guess. – Dincer Apr 30 at 5:41

simply hit :

ctrl + t

while it runs and it will output the progress

load: 1.51  cmd: dd 31215 uninterruptible 0.28u 3.67s
321121+0 records in
321120+0 records out
164413440 bytes transferred in 112.708791 secs (1458745 bytes/sec)
share|improve this answer
Doesn't work for me on Kubuntu Trusty. Possibly conflicting key bindings? – jamadagni Nov 15 '14 at 4:33
Great way. It works under OSX, but does not work under ubuntu 14.04 – Speakus Nov 17 '14 at 6:39
The first line is generated by the OS X, only the latter 3 lines are from dd. – Itay Grudev Apr 1 '15 at 4:49
This is such a simple solution for OSX. Its really annoying that dd stops when you send kill -USR1 on a Mac. – Lightbulb1 Apr 14 '15 at 11:05
You should be able to use kill -INFO on a BSD like OS X – macshome Sep 19 '15 at 13:07

The best is using it is easy to install through apt-get

share|improve this answer
thanks for the pointer to dcfldd, very compatible with dd but some good new features. I especially like the standard progress. – Floyd Dec 20 '13 at 9:46
Why dcfldd isn't more well known is a complete mystery to me. – Freedom_Ben Mar 3 '14 at 14:00
probably for its name. – Giovanni Toraldo Dec 28 '14 at 9:31
yeah most likely because of its name... I just found about it just now. – Tatakai Wasumi Apr 11 at 2:33

If you have already started dd, and if you are writing a file such as when creating a copy of a pendrive to disk, you can use the watch command to constantly observe the size of the output file to see changes and estimate completion.

watch ls -l /pathtofile/filename

To see only file size (h-human view):

watch ls -sh /pathtofile/filename
share|improve this answer
Also a viable method... – hexafraction Dec 7 '12 at 21:59
Useful, though this doesn't necessarily work if you're piping the dd output to something other than a file (eg gzip'ing before writing it to disk). – Wallacoloo Jul 3 '14 at 3:32

For the sake of completeness:

Version 8.24 of the GNU coreutils includes a patch for dd to print the progress per default.

The commit introducing this change has the comment:

dd: new status=progress level to print stats periodically

Many distributions, including the latest version of Ubuntu are using this version now.

share|improve this answer

Native progress status was added to dd!!!

The new version of Coreutils (8.24) adds a progress status to the dd tool:

Usage on Xubuntu 15.10:

Open a terminal and type these commands:

tar -xf coreutils-8.24.tar.xz
cd coreutils-8.24
./configure && make -j $(nproc)

Run dd as root:

sudo su
cd src
./dd if=/dev/sdc of=/dev/sda conv=noerror status=progress

You will see: Bytes, seconds and speed (Bytes/second).

To check the versions of dd:


dd --version


cd coreutils-8.24/src
./dd --version
share|improve this answer


kill -USR1 < dd pid >
share|improve this answer
"pkill -USR1 dd" is the simplest version I'm aware of (as long as you're just running one instance of dd, anyway). On my system I need sudo: "sudo pkill -USR1 dd". Works after you've typed the dd command, and you don't need to install anything new. – Fred Hamilton May 18 '15 at 18:49

The dd | pv | dd triad made my 50GB vm copy take 800 seconds, as opposed to 260 seconds using just dd. With this pipeline, at least, pv has no idea how big the input file is so it won't be able to tell you how far along you are so there's no disadvantage to doing it as follows- and you get a nice speed advantage:

I would avoid pv on anything large, and (if using Bash):

Control-Z the dd process

bg to put it in background. Observe that bg will give you output like [1] 6011 where the latter number is a process id. So, do:

while true; do kill -USR1 process_id ; sleep 5; done

where process_id is the process id you observed. Hit Control-C when you see something like:

[1]+  Done dd if=/path/file.qcow2 of=/dev/kvm/pxetest bs=4194304 conv=sparse
-bash: kill: (60111) - No such process

You are done.

Edit: Silly Systems Administrator! Automate your life, don't work! If I have a long dd process that I want to monitor, here's a one-liner that will take care of the whole enchilada for you; put this all on one line:

 dd if=/path/to/bigimage of=/path/to/newimage conv=sparse bs=262144 & bgid=$!; while true; do sleep 1; kill -USR1 $bgid || break; sleep 4; done

You can, of course, script it, perhaps make $1 your input file and $2 your output file. This is left as an exercise for the reader. Note that you need that little sleep before the kill or the kill may die trying to send a signal to dd when it's not ready yet. Adjust your sleeps as desired (maybe even remove the second sleep altogether).

Bash- FTW! :-)

share|improve this answer
Compress the while loop. Use watch. – muru May 7 '15 at 15:00
@muru it depends. I don't know about your system but on CentOS7* the output is a little garbled; it's readable but does not look orderly. Also it stomps over your previous output so you lose history of the speed of your dd; mine varies between 20 MB/s and 300 MB/s. It's interesting to watch the numbers vary and instructive too. I think some of the large variance is due to LVM thin pools increasing the allocation for an LV I'm writing to. * yes this is an ubuntu forum but I got here looking for "dd monitor progress". It's the first result on Google. – Mike S May 7 '15 at 17:51
Oh, I meant in another terminal or screen window, run sudo watch pkill dd. Then watch dd output the stats comfortably. – muru May 7 '15 at 18:02
Won't pkill send SIGTERM by default? I don't even want to experiment, as pgrep dd comes up with 3 pid's when running a single dd: kthreadd, oddjob, and the dd. I'm afraid of what pkill will do. You could send the -USR1 signal with pkill but again I don't know if that's safe to send to the kernel thread or to obbjob. The watch command looks cleaner but it seems like a lot of extra steps just to avoid a while loop. Generally if I'm doing a dd in one window I'm going to do something right afterwards in the same shell. The while loop is safe: you know EXACTLY which pid gets the signal. – Mike S May 8 '15 at 14:01
mostly I don't care which pids get the signal, since I use watch pkill -USR1 -x dd. Since I also use watch for other similar tasks, this one comes naturally. – muru May 8 '15 at 14:07

I have created bash wrapper over dd that will use pv to show progress. Put it into your .bashrc and use dd as usual:

# dd if=/dev/vvg0/root of=/dev/vvg1/root bs=4M
    2GB 0:00:17 [ 120MB/s] [===========================================================>] 100%            
0+16384 records in
0+16384 records out
2147483648 bytes (2.1 GB) copied, 18.3353 s, 117 MB/s


    local dd=$(which dd); [ "$dd" ] || {
        echo "'dd' is not installed!" >&2
        return 1

    local pv=$(which pv); [ "$pv" ] || {
        echo "'pv' is not installed!" >&2
        "$dd" "$@"
        return $?

    local arg arg2 infile
    local -a args
    for arg in "$@"
        if [ "$arg2" != "$arg" ]

    "$pv" -tpreb "$infile" | "$dd" "${args[@]}"
share|improve this answer
Good way but it does not work with commands like sudo or time. – Speakus Nov 17 '14 at 7:28
Put it into /usr/local/bin/dd with this on top: #!/bin/bash. On bottom: tmp=":${PATH}:"; tmp=${tmp/:/usr/local/bin:/:}; tmp=${tmp%:}; PATH=${tmp#:}; dd "$@" Or you may wish to hardcode dd location. Then use local dd=/usr/bin/dd. Don't forget to add executable bit: chmod +x /usr/local/dd. – midenok Nov 19 '14 at 7:06

On Ubuntu 16.04

Ubuntu 16.04 comes with dd (coreutils) Version 8.25 . Hence the option status=progress is Supported :-)

To use it, just add status=progress along with your dd command.

Example :

dd bs=4M if=/media/severus/tools-soft/OperatingSystems/ubuntu-16.04-desktop-amd64.iso of=/dev/null status=progress && sync

Gives the status as

1282846183 bytes (1.2 GiB, 1.1 GiB) copied, 14.03 s, 101.9 MB/s

enter image description here

share|improve this answer

So today I got a little frustrated with trying to run kill in a loop while dd was running, and came up with this method for running them in parallel, easily:

function vdd {
    sudo dd "$@" &
    sudo sh -c "while pkill -10 ^dd$; do sleep 5; done"

Now just use vdd anywhere you'd normally use dd (it passes all arguments directly through) and you'll get a progress report printed every 5s.

The only downside is that the command doesn't return immediately when dd completes; so it's possible that this command can keep you waiting an extra 5s after dd returns before it notices and exits.

share|improve this answer

As mentioned above, at least with the 'dd' from GNU coreutils, or busybox, it will respond to a USR1 signal by printing progress info to stderr.

I wrote a little wrapper script for dd that shows a nice percent-complete indicator, and tries to not interfere with dd's process or way of functioning in any way. You can find it on github:

Unfortunately, this SIGUSR1 trick only works with either GNU dd (from the coreutils package) or busybox's 'dd' mode with that specific feature enabled at compile time. It doesn't work with the stock 'dd' included with most BSD systems, including FreeBSD and OS X ... :(

share|improve this answer

I really like ddrescue, it works as dd but gives output and doesn't fail on errors, on the contrary it has a very advanced algorithm an tries really hard to do a successful copy... There are also many GUIs for it



enter image description here

share|improve this answer

Your Answer


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.