Você provavelmente já passou por esta situação: baixou a imagem de uma distribuição qualquer, usou o comando dd para gravar a imagem no cartão SD, e ficou esperando, esperando, esperando…

$ sudo dd if=linux.img of=/dev/sdd bs=1M

5 minutos… 10 minutos… 15 minutos… E nada. Será que ainda esta gravando ou travou? Devo reiniciar a gravação?

A verdade é que, dependendo do tamanho da imagem, da interface USB, do leitor ou do próprio cartão SD, o processo de gravação pode levar vários e vários minutos!

Mas não se preocupe! Existem mil e uma maneiras de monitorar o progresso do comando dd. Vamos dar uma olhada em algumas delas?

O SINAL USR1

Se você enviar para o comando dd o sinal USR1, ele irá imprimir as estatísticas de I/O na saída de erro padrão e continuar a execução do comando.

Da página de manual do comando dd:

“Sending a USR1 signal to a running ‘dd’ process makes it print I/O statistics to standard error and then resume copying.”

Portanto, enquanto o comando dd estiver em execução, você pode abrir um outro terminal, identificar o PID (Process ID) do dd e mandar o sinal USR1 para ele, conforme abaixo:

$ pgrep -l '^dd$'
5711 dd
$ sudo kill -USR1 5711

No terminal do comando dd serão exibidas informações sobre seu progresso, para cada sinal enviado:

876+0 records in
876+0 records out
918552576 bytes (919 MB) copied, 19,7349 s, 46,5 MB/s
885+0 records in
885+0 records out
927989760 bytes (928 MB) copied, 20,5903 s, 45,1 MB/s
890+0 records in
890+0 records out
933232640 bytes (933 MB) copied, 21,0879 s, 44,3 MB/s

Com um pouco de magia negra, é possível executar todos os comandos em uma linha só:

$ pgrep -l '^dd$' | cut -d ' ' -f 1 | xargs sudo kill -USR1

Melhor ainda, é possível usar a ferramenta watch para executar o comando a cada 1 segundo:

$ sudo watch -n 1 "pgrep -l ^dd$ | cut -d ' ' -f 1 | xargs kill -USR1"

O SCRIPT DD.SH

Foi pensando nisso que o usuário blindcoder do shellscripts.org criou o projeto ddprogress, que monitora e exibe as estatísticas de forma amigável para o usuário.

O primeiro passo é baixar o script e adicionar permissão de execução:

$ wget http://shellscripts.org/dl/projects/d/ddprogress/version_2/dd.sh
$ chmod +x dd.sh

Então é só usar o script dd.sh no lugar no comando dd:

$ sudo ./dd.sh if=linux.img of=/dev/sdd bs=1M
Getting blocksize from '/dev/sdd': 3842048
In: 1300M (35M/sec) - Out: 1300M (35M/sec) ETA: 00:00:16

A FERRAMENTA DCFLDD

A ferramenta dcfldd é uma versão melhorada do comando dd, que possibilita, dentre outras opções, exibir o status da execução do comando:

No Ubuntu, você pode instalar a ferramenta dcfldd com o comando abaixo:

$ sudo apt-get install dcfldd

Seu uso é idêntico ao comando dd:

$ sudo dcfldd if=linux.img of=/dev/sdd bs=1M
1280 blocks (1280Mb) written.
1300+0 records in
1300+0 records out

PIPE VIEWER

A ferramenta pv (pipe viewer) é a mais interessante de todas as soluções. Simples e funcional, ela basicamente copia a sua entrada padrão (stdin) para a sua saída padrão (stdout), monitorando o progresso da cópia e exibindo estatísticas na saída padrão de erros (stderr).

No Ubuntu, você pode instalar a ferramenta pv com o comando abaixo:

$ sudo apt-get install pv

Sempre sentiu falta de informações de progresso no comando cp? Com o pv é possível copiar um arquivo e exibir o progresso da cópia! Exemplo:

$ pv < /media/videos/movie.mkv > ~/Movies/movie.mkv
952MB 0:00:26 [33,9MB/s] [===>                                 ] 8% ETA 0:04:39

O comando acima copia o arquivo /media/videos/movie.mkv para o destino ~/Movies/movie.mkv, exibindo o progresso da cópia durante a execução do comando.

A mesma técnica pode ser usada no comando dd, para copiar uma imagem para o cartão SD e monitorar o progresso:

$ pv linux.img | sudo dd of=/dev/sdd bs=1M
1,27GB 0:00:53 [24,3MB/s] [====================================>] 100%

É a essência da filosofia Unix, resumida abaixo pelo Dr. Douglas McIlroy, um dos principais engenheiros da Bell Labs e responsável pelo desenvolvimento do mecanismo de pipes e de diversas ferramentas UNIX básicas:

“Write programs that do one thing and do it well. Write programs to work together. Write programs to handle text streams, because that is a universal interface.”

Bacana, não é mesmo?

Um abraço,

Sergio Prado