Como você monitora o progresso do dd?

Question

dd é uma maravilha. Ele permite que você duplique um disco rígido para outro, completamente zero um disco rígido, etc. Mas, depois de iniciar o comando dd , não há nada que lhe avise sobre seu progresso. Apenas fica lá no cursor até que o comando finalmente termine. Então, como se monitora o progresso do dd?

    

Answer 1

De HowTo: Monitore o progresso do dd

Você pode monitorar o progresso do dd sem pará-lo usando o comando kill .

Para ver o progresso de dd assim que ele estiver em execução, abra outro terminal e digite:

sudo kill -USR1 $(pgrep ^dd)

Isso exibirá dd progress na janela do terminal dd sem interromper o processo. Se você estiver no BSD ou OS X, use INFO em vez de USR1 . O sinal USR1 terminará dd.

Se você deseja receber atualizações regulares do dd progress, digite:

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

watch examinará o processo dd a cada -n segundos ( -n5 = 5 segundos) e informará sem interrompê-lo.

Observe as aspas simples apropriadas nos comandos acima.

    

Answer 2

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

Método 1: usando pv

Instale pv e coloque-o entre os comandos dd de entrada / saída.

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

Na descrição do pacote :

% bl0ck_qu0te%

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 --size se quiser uma estimativa de tempo.

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

Comando sem pv seria:

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

Saída:

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

Outros usos

Você pode usar o pv diretamente para canalizar a saída para a stdout:

pv /home/user/bigfile.iso | md5sum

Resultado

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

Observe que, neste caso, pv reconhece o tamanho automaticamente.

Método 2: Nova opção status adicionada a dd (GNU Coreutils 8.24 +)

dd no GNU Coreutils 8.24+ (Ubuntu 16.04 e mais recente) recebeu uma nova opção status para exibir o progresso:

Exemplo

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

Saída

462858752 bytes (463 MB, 441 MiB) copied, 38 s, 12,2 MB/s

    

Answer 3

Alguns exemplos úteis de uso com pv e menos digitação ou mais progresso, em seguida, outras respostas:

Primeiro, você precisará instalar o 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 tem 5 caracteres a menos de digitação do que dd if=/dev/urandom | pv | dd of=/dev/null .}

E o meu favorito para clonar uma unidade de disco:

(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

fonte: link

_{Também para me arquivar.}

    

Answer 4

Use Ctrl + Deslocamento + T enquanto dd está rodando, e ele mostrará 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)

    

Answer 5

Por questões de integridade:

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

O commit que introduz esta mudança tem o comentário :

% bl0ck_qu0te%

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

    

Answer 6

O melhor é usar o link que é fácil de instalar através do apt-get

    

Answer 7

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

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

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 dd como 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

    

Answer 8

Se você já iniciou o dd, e se está escrevendo um arquivo como ao criar uma cópia de um pendrive para o 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 (h-human view):

watch ls -sh /pathtofile/filename

    

Answer 9

A tríade dd | pv | dd fez minha cópia de 50 GB de vm demorar 800 segundos, ao contrário de 260 segundos usando apenas dd. Com esse pipeline, pelo menos, pv não tem idéia do tamanho do arquivo de entrada, então ele não será capaz de dizer a você o quanto você está, então não há desvantagem em fazê-lo da seguinte maneira - e você terá uma boa vantagem de velocidade:

Eu evitaria pv em algo grande e (se estiver usando Bash):

Control-Z o processo dd

bg para colocar em segundo plano. Observe que bg fornecerá a saída como [1] 6011 , em que o último número é um ID do processo. Então, faça:

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

onde process_id é o ID do processo que você observou. Hit Control-C quando você vê 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 eu quero monitorar, aqui está um one-liner 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 o script, talvez fazer $ 1 do seu arquivo de entrada e $ 2 do seu arquivo de saída. Isso é deixado como um exercício para o leitor. Note que você precisa de um pouco de sono antes que o kill ou o kill morram, tentando enviar um sinal para o dd quando ainda não estiver pronto. Ajuste seus sonos conforme desejado (talvez até mesmo remova o segundo suspiro).

Bash-FTW! : -)

    

Answer 10

link

Basicamente:

kill -USR1 < dd pid >

    

Answer 11

No Ubuntu 16.04

O Ubuntu 16.04 vem com a versão dd (coreutils) 8.25 . Daí a opção status=progress é Suportado: -)

Para usá-lo, basta adicionar status=progress junto com o comando dd .

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 como

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

    

Answer 12

O mais fácil é:

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

oflag=dsync manterá sua escrita em sincronia, para que as informações de status=progress sejam mais precisas. No entanto, pode ser um pouco mais lento.

    

Answer 13

Eu criei o wrapper bash em dd que usará pv para mostrar o progresso. Coloque em seu .bashrc e use dd como de costume:

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

    

Answer 14

Eu gosto muito do ddrescue, ele funciona como dd mas dá saída e não falha em erros, pelo contrário ele tem um algoritmo muito avançado e tenta fazer uma cópia bem sucedida ... Há também muitas GUIs para isso

Projeto: link

Wikipedia: link

    

Answer 15

Hoje, fiquei um pouco frustrado ao tentar executar kill em um loop enquanto dd estava em execução e criei esse método para executá-los em paralelo, com facilidade:

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

Agora é só usar vdd em qualquer lugar onde você usaria normalmente dd (ele passará todos os argumentos diretamente) e você receberá um relatório de progresso impresso a cada 5s.

A única desvantagem é que o comando não retorna imediatamente quando o dd é concluído; Por isso, é possível que esse comando possa fazer com que você espere 5 segundos extras depois que o dd retornar antes que ele seja notificado e saia.

    

Answer 16

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

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

Exemplo:

sudo dd if=mydistrib.iso of=/dev/sdb status=progress conv=fsync

    

Answer 17

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

Pode monitorar:

cp mv dd tar gato rsync grep fgrep egrep cortar tipo md5sum sha1sum sha224sum sha256sum sha384sum sha512sum adz gzip gunzip bzip2 bunzip2 xz unxz lzma unlzma 7z 7 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 está sendo executado ou iniciá-lo com o comando dd:

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

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

O comando de progresso é iniciado com: -m , para que ele aguarde até que o processo monitorado termine, -p para monitorar um determinado pid e $! é o último comando pid.

Se você der dd com sudo, você também tem que progredir:

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

    

Answer 18

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

Eu escrevi um pequeno script de wrapper para dd que mostra um bom indicador percentual completo, e tenta não interferir no processo ou na maneira de funcionar do dd de qualquer forma. Você pode encontrá-lo no github:

link

Infelizmente, esse truque SIGUSR1 funciona apenas com o GNU dd (do pacote coreutils) ou com o modo 'dd' do busybox, com esse recurso específico ativado em tempo de compilação. Não funciona com o stock 'dd' incluído na maioria dos sistemas BSD, incluindo FreeBSD e OS X ...: (

    

Answer 19

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

watch killall -USR1 dd

Para mudar de 2 em 2 segundos para 5 segundos, adicione a opção -n 5 assim:

watch -n 5 killall -USR1 dd