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?

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

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.

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

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

_{Também para me arquivar.}

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)

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.

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

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

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

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! :-)

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

Basicamente:

kill -USR1 < dd pid >

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.

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

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

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

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[@]}"
}

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.

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

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.

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 ... :(

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