Como você monitora o progresso do dd?

654

ddé uma maravilha. Permite duplicar um disco rígido para outro, zerar completamente um disco rígido, etc. Mas, depois que você inicia um ddcomando, não há nada para lhe dizer sobre seu progresso. Ele fica lá no cursor até o comando finalmente terminar. Então, como monitorar o progresso de dd?

James
fonte

Respostas:

729

Atualização 2016 : Se você usa o GNU coreutils> = 8.24 (padrão no Ubuntu Xenial 16.04 para cima), consulte o método 2 abaixo para obter uma maneira alternativa de exibir o progresso.


Método 1: usando pv

Instale pve coloque-o entre os ddcomandos somente de entrada / saída .

Nota : você não pode usá-lo quando você já iniciou dd.

Na descrição do pacote :

pv- Pipe Viewer - é uma ferramenta baseada em terminal para monitorar o progresso dos dados através de um pipeline. Ele pode ser inserido em qualquer pipeline normal entre dois processos para fornecer uma indicação visual da rapidez com que os dados estão passando, quanto tempo demorou, quão perto está da conclusão e uma estimativa de quanto tempo levará até a conclusão.

Instalação

sudo apt-get install pv

Exemplo

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

Resultado

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

Você pode especificar o tamanho aproximado com o --sizese desejar uma estimativa de tempo.


Exemplo Supondo que um disco de 2 GB seja copiado de / dev / sdb

Comando sem pvseria:

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

Comando com pv:

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

Resultado:

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

Outros usos

Obviamente, você pode usar pvdiretamente para canalizar a saída para o stdout:

pv /home/user/bigfile.iso | md5sum

Resultado

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

Observe que, nesse caso, pvreconhece o tamanho automaticamente.


Método 2: Nova statusopção adicionada ao dd(GNU Coreutils 8.24+)

ddno GNU Coreutils 8.24+ (Ubuntu 16.04 e versões mais recentes) obteve uma nova statusopção para exibir o progresso:

Exemplo

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

Resultado

462858752 bytes (463 MB, 441 MiB) copied, 38 s, 12,2 MB/s
phoibos
fonte
76
pv bigfile.iso | dd de = / dev / seu dispositivo
Ion Br.
18
Note-se que os parâmetros para "dd" são apropriadas na primeira metade (a parte de entrada do tubo): dd if=/dev/zero bs=1M count=35000 | pv | dd of=VirtualDisk.raw.
Sopalajo de Arrierez 28/03
6
pv bigfile.iso | dd of=VirtualDisk.raw bs=1M count=35000obras, verificadas. @SopalajodeArrierez, os parâmetros podem ser dados no segundo dd.
SiddharthaRT
11
usando pv < /dev/sda > /dev/sdbparece ficar melhor velocidade ( fonte )
Nicola Feltrin
14
FYI na velocidade. Testes no meu computador com o Samsung 840 PRO SSD: dd if=/dev/urandom | pv | of=/dev/sdbfornecem ~ 18MB / s de gravação, dd if=/dev/zero | pv | of=/dev/sdb~ 80MB / s, e o velho comum dd if=/dev/zero of=/dev/sdbfornece ~ 550MB / s (próximo à velocidade máxima de gravação do SSD). Tudo com bs=4096000.
Tedd Hansen
461

Do HowTo: Monitorar o progresso do dd

Você pode monitorar o progresso do dd sem interrompê-lo usando o killcomando

Para ver o progresso de dduma vez em execução, abra outro terminal e digite:

sudo kill -USR1 $(pgrep ^dd)

Isso exibirá o ddprogresso na ddjanela do terminal sem interromper o processo. Se você estiver no BSD ou no OS X, use em INFOvez de USR1. O USR1sinal terminará dd.

Se você deseja obter atualizações regulares do ddprogresso, digite:

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

watchsondará o ddprocesso a cada -n segundos ( -n5= 5 segundos) e relatará sem interromper.

Observe as aspas simples apropriadas nos comandos acima.

James
fonte
19
Isso funcionou, mas alguns comentários. Primeiro de tudo, não sei por que você escapou dos seus backticks (se é para o editor de SO, você fez isso incorretamente). Em segundo lugar, eu recomendaria o uso de ^ dd $, caso algo esteja sendo executado com o prefixo dd. Finalmente, você não precisa do sudo para enviar o sinal USR1. Caso contrário, boa resposta, +1.
gsingh2011
22
NB! Dessa forma, interrompe o trabalho do dd no OSX.
Maxim Kholyavkin
26
@ Speakus Você precisa usar kill -INFO $(pgrep ^dd$)em sistemas BSD (como o OSX).
Torben
20
sudo pkill -usr1 ddé mais fácil de lembrar, funciona perfeitamente (pelo menos no Ubuntu 14.04) e é menos digitado.
Phizes
21
Gosto disso porque tenho medo de pvretardar a transferência, como TeddHansen mostrou. Além disso, aposto que muitas pessoas pesquisam isso no Google porque iniciaram a ddoperação;)
sudo
104

Alguns exemplos úteis de uso com pvmenos digitação ou mais progresso do que outras respostas:

Primeiro você precisará instalar pv, com o comando:

sudo apt-get install pv

Então, alguns exemplos são:

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

Nota: a primeira amostra possui 5 caracteres a menos que digita dd if=/dev/urandom | pv | dd of=/dev/null.

E o meu favorito para clonar uma unidade de disco (substitua X pelas letras da unidade):

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

captura de tela

fonte: http://www.cyberciti.biz/faq/linux-unix-dd-command-show-progress- while- coping/

Também para me arquivar.

JSBach
fonte
3
você precisará instalar também dialogcom o comandoapt-get install dialog
k7k0
7
AME o dialogexemplo. SERENIDADE AGORA !
Alex Gray
Você só pode chamar esse diálogo com python?
Mikeymop
1
Graças a esta resposta, descobri que dialogisso ajudará insanamente a escrever scripts de shell: D
holms
2
brew install pv dialogpara Mac. Também este cavalheiro calcula com estilo. Bravo.
evilSnobu
62

Use Ctrl+ Shift+ Tenquanto ddestiver em execução e ele produzirá o progresso (em bytes):

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)
01010101
fonte
5
Não funciona para mim no Kubuntu Trusty. Ligações de teclas possivelmente conflitantes?
Jamadagni
14
Excelente maneira. Ele funciona no OSX, mas não no ubuntu 14.04
Maxim Kholyavkin
1
A primeira linha é gerada pelo OS X, apenas as três últimas são dd.
Itay Grudev
3
Você deve ser capaz de usar matar -Info em um BSD como OS X
macshome
3
Isso não funciona no Ubuntu. Ctrl-T / Ctrl-Shift-T apenas envia ^Tpara o terminal (exceto que muitos aplicativos de terminal interceptam Ctrl-Shift-T e abrem uma nova guia). Muitos pesquisadores no OSX / BSD pode apreciar esta resposta, mas deve ficar claro que não é para Ubuntu (ou GNU / Linux em geral?)
mwfearnley
60

Por uma questão de completude:

A versão 8.24 dos coreutils do GNU inclui um patch para o dd introduzindo um parâmetro para imprimir o progresso.

O commit que introduziu essa alteração tem o comentário:

dd: new status = nível de progresso para imprimir estatísticas periodicamente

Muitas distribuições, incluindo o Ubuntu 16.04.2 LTS, usam esta versão.

davidDavidson
fonte
só quero adicionar como eu compilei o 8.24 coreutils: apt install build-essentiale apt-get build-dep coreutils, faça o download do coreutils-8.25.tar.xz, tar xvf coreutils-8.25.tar.xz configure --prefix=$HOME/usr/locale execute make. Recém compilado ddestará sob srcdir. Você pode copiá-lo para / bin e substituir existente ou jus executados como src / DD
holms
2
Legal! Eu gosto desse recurso. E levou apenas cerca de 30 anos para ensinar o dd a imprimir a saída do progresso. :-)
Johannes Overmann
Que alivio! Vou adicionar imediatamente esse argumento em um apelido de shell dd.
Stephan Henningsen
Observe que o status às vezes é impresso com dois números, um em unidades SI e o valor equivalente em unidades binárias (por exemplo, 10 MB, 9,5 MiB).
Palswim
33

O melhor é usar http://dcfldd.sourceforge.net/ , é fácil de instalar através do apt-get

TheNano
fonte
3
obrigado pelo ponteiro para dcfldd, muito compatível com dd, mas com alguns bons recursos novos. Eu gosto especialmente do progresso padrão.
Floyd
4
Por que o dcfldd não é mais conhecido é um completo mistério para mim.
Freedom_Ben
28
provavelmente pelo seu nome.
Giovanni Toraldo
Possui as opções de dde opção status=onpor padrão, para mensagens de progresso statusinterval=N(N em blocos) para a frequência de atualização de mensagens e sizeprobe=[if|of]para um indicador de porcentagem. Vou apelidar-lo para DD:)
Kavadias
25

O status de progresso nativo foi adicionado ao dd !!!

A nova versão do Coreutils (8.24) adiciona um status de progresso à ddferramenta:

Uso no Xubuntu 15.10:

Abra um terminal e digite estes comandos:

wget ftp://ftp.gnu.org/pub/gnu/coreutils/coreutils-8.24.tar.xz
tar -xf coreutils-8.24.tar.xz
cd coreutils-8.24
./configure && make -j $(nproc)

Executar ddcomo root:

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

Você verá: Bytes, segundos e velocidade (Bytes / segundo).

Para verificar as versões de dd:

Nativo:

dd --version

Novo:

cd coreutils-8.24/src
./dd --version
user3394963
fonte
18

Se você já iniciou o dd e está escrevendo um arquivo, como ao criar uma cópia de um pendrive no disco, pode usar o comando watch para observar constantemente o tamanho do arquivo de saída para ver as alterações e estimar a conclusão.

watch ls -l /pathtofile/filename

Para ver apenas o tamanho do arquivo (exibição h-humana):

watch ls -sh /pathtofile/filename
fabricator4
fonte
Também é um método viável ...
ζ-- 07/12/12
3
Útil, embora isso não funcione necessariamente se você estiver direcionando a saída dd para algo diferente de um arquivo (por exemplo, gzipando antes de gravá-la no disco).
Ponkadoodle
Não funciona em arquivos especiais.
Johannes Overmann
13

A dd | pv | ddtríade fez minha cópia de 50GB vm demorar 800 segundos, em vez de 260 segundos usando apenas dd. Com esse pipeline, pelo menos, o pv não tem idéia de quão grande é o arquivo de entrada, para que não seja capaz de lhe dizer quanto tempo você está, portanto, não há desvantagem em fazê-lo da seguinte maneira - e você obtém uma boa vantagem de velocidade:

Eu evitaria o pv em qualquer coisa grande e (se estiver usando o Bash):

Control-Z o processo dd

bgpara colocá-lo em segundo plano. Observe que bgvocê fornecerá uma saída como [1] 6011onde o último número é uma identificação de processo. Então faz:

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

onde process_id é a identificação do processo que você observou. Pressione Control-C quando vir algo como:

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

Você terminou.

Edit: Administrador de Sistemas Silly! Automatize sua vida, não trabalhe! Se eu tenho um longo processo de dd que quero monitorar, aqui está uma lista que cuidará de toda a enchilada para você; coloque tudo isso em uma linha:

 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

Você pode, é claro, fazer um script, talvez transformar $ 1 em seu arquivo de entrada e $ 2 em seu arquivo de saída. Isso é deixado como um exercício para o leitor. Observe que você precisa de um pouco de sono antes que a matança ou a matança possam morrer tentando enviar um sinal para dd quando ainda não estiver pronto. Ajuste o sono conforme desejado (talvez até remova o segundo sono completamente).

Bash- FTW! :-)

Mike S
fonte
1
Comprima o whileloop. Use watch.
muru
1
@ muru depende. Eu não sei sobre o seu sistema, mas no CentOS7 * a saída é um pouco distorcida; é legível, mas não parece ordenado. Também pisa sobre sua saída anterior, para que você perca o histórico da velocidade do seu dd; o meu varia entre 20 MB / se 300 MB / s. É interessante ver os números variarem e instrutivos também. Eu acho que parte da grande variação é devida aos thin pools do LVM aumentando a alocação para um LV no qual estou escrevendo. * Sim, este é um fórum do Ubuntu, mas cheguei aqui procurando por "dd monitor progress". É o primeiro resultado no Google.
Mike S
Ah, eu quis dizer em outro terminal ou janela da tela, corra sudo watch pkill dd. Então assista ddas estatísticas de saída confortavelmente.
muru
O pkill não enviará o SIGTERM por padrão? Eu nem quero experimentar, pois o pgrep dd oferece 3 pids ao executar um único dd: kthreadd, oddjob e o dd. Eu tenho medo do que pkill fará. Você pode enviar o sinal -USR1 com pkill, mas novamente não sei se é seguro enviar para o thread do kernel ou obbjob. O comando watch parece mais limpo, mas parece haver várias etapas extras apenas para evitar um loop while. Geralmente, se estou fazendo um dd em uma janela, farei algo logo depois no mesmo shell. O loop while é seguro: você sabe EXATAMENTE qual pid recebe o sinal.
Mike S
principalmente, eu não ligo para quais pids recebem o sinal, já que eu uso watch pkill -USR1 -x dd. Desde que eu também uso watchpara outras tarefas semelhantes, esta vem naturalmente.
muru
11

http://linuxcommando.blogspot.com/2008/06/show-progress-during-dd-copy.html

Basicamente:

kill -USR1 < dd pid >
hnasarat
fonte
1
"pkill -USR1 dd" é a versão mais simples que eu conheço (desde que você esteja executando apenas uma instância do dd). No meu sistema, preciso do sudo: "sudo pkill -USR1 dd". Funciona depois que você digita o comando dd e não precisa instalar nada de novo.
Fred Hamilton
7

O mais fácil é:

 dd if=... of=... bs=4M status=progress oflag=dsync

oflag=dsyncmanterá sua escrita sincronizada, para que as informações status=progresssejam mais precisas. No entanto, pode ser um pouco mais lento.

zevero
fonte
1
de acordo com gnu.org/software/coreutils/manual/html_node/dd-invocation.html , usando conv=fsyncé melhor
Chen Deng-Ta
Obrigado por isso! Estou fazendo dd para um lvm2 remoto e o bs = 4M aumentou minha transferência em um fator de 20 e a indicação de progresso é maravilhosa.
Lonnie Melhor
6

No Ubuntu 16.04

O Ubuntu 16.04 vem com a versão 8.25 do dd (coreutils) . Portanto, a opção status=progress é suportada :-)

Para usá-lo, basta adicionar status=progressjunto com o seu ddcomando.

Exemplo:

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

Dá o status de

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

insira a descrição da imagem aqui

Severus Tux
fonte
5

Use a opção status=progresspara obter o progresso durante a transferência.

Além disso, conv=fsyncexibirá erros de E / S.

Exemplo:

sudo dd if=mydistrib.iso of=/dev/sdb status=progress conv=fsync
MUY Bélgica
fonte
4

Eu realmente gosto de ddrescue, ele funciona como dd, mas gera resultados e não falha em erros, pelo contrário, possui um algoritmo muito avançado e tenta realmente fazer uma cópia bem-sucedida ... Existem também muitas GUIs para isso

Projeto: https://www.gnu.org/software/ddrescue

Wikipedia: https://en.wikipedia.org/wiki/Ddrescue

insira a descrição da imagem aqui

SuperMau
fonte
3

Eu criei o wrapper bash ddque será usado pvpara mostrar o progresso. Coloque-o no seu .bashrce use- ddo normalmente:

# 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

Fonte:

dd()
{
    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 "$@"
    do
        arg2=${arg#if=}
        if [ "$arg2" != "$arg" ]
        then
            infile=$arg2
        else
            args[${#args[@]}]=$arg
        fi
    done

    "$pv" -tpreb "$infile" | "$dd" "${args[@]}"
}
midenok
fonte
Boa maneira, mas não funciona com comandos como sudo ou time.
Maxim Kholyavkin
1
Colocá-lo em / usr / local / bin / dd com isso em cima: #!/bin/bash. Na parte inferior: tmp=":${PATH}:"; tmp=${tmp/:/usr/local/bin:/:}; tmp=${tmp%:}; PATH=${tmp#:}; dd "$@"ou você pode codificar a ddlocalização. Então use local dd=/usr/bin/dd. Não se esqueça de adicionar bit executável: chmod +x /usr/local/dd.
midenok
2

Hoje, fiquei um pouco frustrado ao tentar executar killum loop enquanto ddestava em execução e criei esse método para executá-los em paralelo, facilmente:

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

Agora basta usar em vddqualquer lugar que você normalmente usaria dd(ele passa todos os argumentos diretamente) e você obterá um relatório de progresso impresso a cada 5s.

A única desvantagem é que o comando não retorna imediatamente quando o dd é concluído; portanto, é possível que esse comando possa esperar 5s extras depois que o dd retornar antes que ele note e saia.

robru
fonte
2

Isso força o dd a fornecer estatísticas a cada 2 segundos, que é o padrão para o relógio:

watch killall -USR1 dd

Para alterar a cada 2 segundos a cada 5 segundos, adicione a opção -n 5 como esta:

watch -n 5 killall -USR1 dd
Kostyantyn
fonte
2

Apenas no caso de alguém do CentOS ter encontrado esse tópico ...

A opção 'status = progress' funciona com o CentOS 7.5 e 7.6

A resposta acima de @davidDavidson implica que o recurso foi adicionado recentemente no Coreutils 8.24.

A versão 8.24 dos coreutils do GNU inclui um patch para o dd introduzindo um parâmetro para imprimir o progresso.

Pode ser esse o caso, mas o CentOS pode não estar seguindo o mesmo esquema de versão.

A versão do Coreutils que acompanha o CentOS 7.6.1810 é:

coreutils-8.22-23.el7.x86_64 : A set of basic GNU tools commonly used in shell scripts

E a versão do dd instalada é:

[root@hostname /]# dd --version
dd (coreutils) 8.22
Copyright (C) 2013 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Written by Paul Rubin, David MacKenzie, and Stuart Kemp.

Isso mostra as versões 8.22 .

No entanto, testei o 'status = progress' com o dd no CentOS 7.5 e no CentOS 7.6 (ambos com a versão 8.22 do Coreutils) e ele funciona corretamente.

Não sei por que o RedHat escolhe usar uma versão tão antiga do Coreutils, mas a funcionalidade existe com a 8.22.

J Hauss
fonte
1

Como mencionado acima, pelo menos com o 'dd' do GNU coreutils, ou busybox, ele responderá a um sinal USR1 imprimindo informações de progresso no stderr.

Escrevi um pequeno script wrapper para o dd que mostra um bom indicador de porcentagem completa e tenta não interferir no processo ou no modo de funcionamento do dd. Você pode encontrá-lo no github:

http://github.com/delt01/dd_printpercent

Infelizmente, esse truque do SIGUSR1 funciona apenas com o GNU dd (do pacote coreutils) ou o modo 'dd' do busybox com esse recurso específico ativado no momento da compilação. Ele não funciona com o estoque 'dd' incluído na maioria dos sistemas BSD, incluindo FreeBSD e OS X ... :(

delt
fonte
O link está morto.
ishmael 04/09
1

Você pode assistir o progresso de qualquer programa coreutils usando progress - Coreutils Progress Viewer.

Pode monitorar:

cp mv dd tar cat rsync grep fgrep egrep cut sort md5sum sha1sum sha224sum sha256sum sha384sum sha512sum adb gzip gunzip bzip2 bunzip2 xz unxz lzma unlzma 7z 7za zcat bzcat lzcat split gpg

Você pode ver a página de manual

Você pode usá-lo em uma janela de terminal separada enquanto o comando estiver em execução ou iniciá-lo com o comando dd:

dd if=/dev/sda of=file.img & progress -mp $!

Aqui &bifurca-se o primeiro comando e continua imediatamente, em vez de esperar até que o comando termine.

O comando progress é iniciado com: -mportanto, aguarda até o processo monitorado terminar, -ppara monitorar um determinado pid e $!é o último comando pid.

Se você emitir dd com o sudo, também precisará fazer progresso:

sudo dd if=/dev/sda of=file.img &
sudo progress -m
# with no -p, this will wait for all coreutil commands to finish
# but $! will give the sudo command's pid
labsin
fonte