ddè una meraviglia. Ti consente di duplicare un disco rigido su un altro, azzerare completamente un disco rigido, ecc. Ma una volta avviato un ddcomando, non c'è nulla che ti dica dei suoi progressi. Si trova lì sul cursore fino a quando il comando non termina. Quindi, come si fa a monitorare i progressi di dd?

Aggiornamento 2016 : se usi GNU coreutils> = 8.24 (impostazione predefinita in Ubuntu Xenial 16.04 in poi), vedi il metodo 2 sotto per un modo alternativo per visualizzare l'avanzamento.

Metodo 1: utilizzando pv

Installa pve inseriscilo tra i ddcomandi di input / output .

Nota : non puoi usarlo quando hai già iniziato dd.

Dalla descrizione del pacchetto :

pv- Pipe Viewer - è uno strumento basato su terminali per monitorare l'avanzamento dei dati attraverso una pipeline. Può essere inserito in qualsiasi normale pipeline tra due processi per fornire un'indicazione visiva di quanto velocemente passano i dati, quanto tempo ha impiegato, quanto è vicino al completamento e una stima di quanto tempo sarà fino al completamento.

Installazione

sudo apt-get install pv

Esempio

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

Produzione

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

È possibile specificare la dimensione approssimativa con --sizese si desidera una stima del tempo.

Esempio Supponendo che un disco da 2 GB sia copiato da / dev / sdb

Il comando senza pvsarebbe:

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

Comando con pv:

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

Produzione:

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

Altri usi

Ovviamente puoi usare pvdirettamente per reindirizzare l'output a stdout:

pv /home/user/bigfile.iso | md5sum

Produzione

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

Si noti che in questo caso, pvriconosce automaticamente le dimensioni.

Metodo 2: Nuova statusopzione aggiunta a dd(GNU Coreutils 8.24+)

ddin GNU Coreutils 8.24+ (Ubuntu 16.04 e versioni successive) è disponibile una nuova statusopzione per visualizzare l'avanzamento:

Esempio

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

Produzione

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

Da HowTo: monitorare l'avanzamento di dd

È possibile monitorare l'avanzamento di dd senza arrestarlo utilizzando il killcomando.

Per vedere l'avanzamento di dduna volta in esecuzione, apri un altro terminale ed inserisci:

sudo kill -USR1 $(pgrep ^dd)

Ciò visualizzerà l' ddavanzamento nella ddfinestra del terminale senza interrompere il processo. Se usi BSD o OS X, usa INFOinvece di USR1. Il USR1segnale terminerà dd.

Se desideri ricevere aggiornamenti regolari ddsull'avanzamento, inserisci:

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

watchesaminerà il ddprocesso ogni -n secondi ( -n5= 5 secondi) e segnalerà senza arrestarlo.

Nota le virgolette singole appropriate nei comandi sopra.

Alcuni utili esempi di utilizzo con pve meno digitazione o più progressi rispetto ad altre risposte:

Per prima cosa dovrai installare pv, con il comando:

sudo apt-get install pv

Quindi alcuni esempi sono:

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

^{Nota: il primo esempio è di 5 caratteri in meno digitando allora dd if=/dev/urandom | pv | dd of=/dev/null.}

E il mio preferito per la clonazione di un'unità disco (sostituire X con lettere di unità):

(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/

_{Anche per l'archiviazione.}

Usa Ctrl+ Shift+ Tmentre ddè in esecuzione e genererà l'avanzamento (in byte):

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)

Per amor di completezza:

La versione 8.24 dei coreutils GNU include una patch per dd che introduce un parametro per stampare l'avanzamento.

Il commit che introduce questa modifica ha il commento:

dd: nuovo stato = livello di avanzamento per stampare periodicamente le statistiche

Molte distribuzioni, tra cui Ubuntu 16.04.2 LTS utilizzano questa versione.

Il migliore è usare http://dcfldd.sourceforge.net/ è facile da installare tramite apt-get

Lo stato di avanzamento nativo è stato aggiunto a dd !!!

La nuova versione di Coreutils (8.24) aggiunge uno stato di avanzamento allo ddstrumento:

Utilizzo su Xubuntu 15.10:

Apri un terminale e digita questi comandi:

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)

Esegui ddcome root:

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

Vedrai: byte, secondi e velocità (byte / secondo).

Per verificare le versioni di dd:

Native:

dd --version

Nuovo:

cd coreutils-8.24/src
./dd --version

Se hai già avviato dd e se stai scrivendo un file come quando si crea una copia di un pendrive su disco, è possibile utilizzare il comando watch per osservare costantemente le dimensioni del file di output per vedere le modifiche e stimare il completamento.

watch ls -l /pathtofile/filename

Per visualizzare solo le dimensioni del file (vista h-human):

watch ls -sh /pathtofile/filename

La dd | pv | ddtriade ha fatto in modo che la mia copia da 50 GB vm impiegasse 800 secondi, anziché 260 secondi usando solo dd. Con questa pipeline, almeno, pv non ha idea di quanto sia grande il file di input, quindi non sarà in grado di dirti quanto siete lontani, quindi non ci sono svantaggi nel farlo come segue e otterrete un bel vantaggio di velocità:

Eviterei il pv su qualsiasi cosa di grandi dimensioni e (se uso Bash):

Control-Z il processo dd

bgper metterlo in background. Osserva che bgti darà un output come [1] 6011dove l'ultimo numero è un ID di processo. Quindi, fai:

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

dove process_id è l'id del processo che hai osservato. Premi Control-C quando vedi qualcosa del tipo:

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

Hai fatto.

Modifica: Silly Systems Administrator! Automatizza la tua vita, non lavorare! Se ho un lungo processo dd che voglio monitorare, ecco un one-liner che si occuperà dell'intera enchilada per te; metti tutto su una riga:

 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

Puoi, ovviamente, scriverlo, forse rendere $ 1 il tuo file di input e $ 2 il tuo file di output. Questo è lasciato come esercizio per il lettore. Nota che hai bisogno di quel poco sonno prima che l'uccisione o l'uccisione possa morire provando a inviare un segnale a dd quando non è ancora pronto. Regola i tuoi dormi come desideri (magari rimuovi del tutto il secondo sonno).

Bash- FTW! :-)

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

Fondamentalmente:

kill -USR1 < dd pid >

Il più semplice è:

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

oflag=dsyncmanterrà la tua scrittura sincronizzata, quindi le informazioni di saranno status=progresspiù accurate. Tuttavia potrebbe essere un po 'più lento.

Su Ubuntu 16.04

Ubuntu 16.04 viene fornito con dd (coreutils) Versione 8.25 . Quindi l'opzione status=progress è supportata :-)

Per usarlo, basta aggiungere status=progresscon il tuo ddcomando.

Esempio :

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

Fornisce lo stato come

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

Utilizzare l'opzione status=progressper ottenere l'avanzamento durante il trasferimento.

Inoltre, conv=fsyncvisualizzerà errori I / O.

Esempio:

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

Mi piace molto ddrescue, funziona come dd ma dà output e non fallisce in caso di errori, al contrario ha un algoritmo molto avanzato e fa davvero fatica a fare una copia di successo ... Ci sono anche molte GUI per questo

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

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

Ho creato un wrapper bash ddche verrà utilizzato pvper mostrare i progressi. Mettilo nel tuo .bashrce usa ddcome al solito:

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

Quindi oggi sono stato un po 'frustrato nel provare a correre killin un ciclo mentre ddera in esecuzione e ho trovato questo metodo per eseguirli in parallelo, facilmente:

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

Ora basta usare vddovunque tu normalmente usi dd(passa direttamente tutti gli argomenti) e otterrai un rapporto sui progressi stampato ogni 5 secondi.

L'unico aspetto negativo è che il comando non ritorna immediatamente al completamento di dd; quindi è possibile che questo comando possa farti aspettare altri 5 secondi dopo che dd ritorna prima che si accorga e si chiuda.

Questo impone dd di fornire statistiche ogni 2 secondi, valore predefinito per l'orologio:

watch killall -USR1 dd

Per passare da ogni 2 secondi a ogni 5 secondi, aggiungi l'opzione -n ​​5 in questo modo:

watch -n 5 killall -USR1 dd

Nel caso in cui qualcuno dalla terra CentOS trovi questa discussione ...

L'opzione 'status = progress' funziona con CentOS 7.5 e 7.6

La risposta sopra di @davidDavidson implica che la funzionalità è stata recentemente aggiunta in Coreutils 8.24.

La versione 8.24 dei coreutils GNU include una patch per dd che introduce un parametro per stampare l'avanzamento.

Questo può essere il caso, ma CentOS potrebbe non seguire lo stesso schema di controllo delle versioni.

La versione di Coreutils fornita con CentOS 7.6.1810 è:

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

E la versione di dd installata è:

[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.

Questo mostra le versioni 8.22 .

Tuttavia, ho testato "status = progress" con dd su CentOS 7.5 e CentOS 7.6 (entrambi con la versione 8.22 di Coreutils) e funziona correttamente.

Non so perché RedHat scelga di utilizzare una versione così vecchia di Coreutils ma la funzionalità esiste con 8.22.

Come accennato in precedenza, almeno con 'dd' da GNU coreutils, o busybox, risponderà a un segnale USR1 stampando le informazioni di avanzamento su stderr.

Ho scritto un piccolo script wrapper per dd che mostra un buon indicatore di percentuale completa e cerca di non interferire in alcun modo con il processo o il modo di funzionare di dd. Puoi trovarlo su github:

http://github.com/delt01/dd_printpercent

Sfortunatamente, questo trucco di SIGUSR1 funziona solo con GNU dd (dal pacchetto coreutils) o con la modalità 'dd' di busybox con quella specifica funzione abilitata al momento della compilazione. Non funziona con lo stock 'dd' incluso con la maggior parte dei sistemi BSD, inclusi FreeBSD e OS X ... :(

Puoi vedere lo stato di avanzamento di qualsiasi programma coreutils usando progress - Coreutils Progress Viewer.

Può monitorare:

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

Puoi vedere la manpage

Puoi usarlo in una finestra terminale separata mentre il comando è in esecuzione o avviarlo con il comando dd:

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

Qui &biforca il primo comando e continua immediatamente invece di attendere fino alla fine del comando.

Il comando progress viene avviato con: -mquindi attende fino al termine del processo monitorato, -pquindi monitora un determinato pid ed $!è l'ultimo comando pid.

Se emetti dd con sudo, devi farlo anche con i progressi:

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