De HowTo: Surveillez la progression de dd

Vous pouvez surveiller la progression de dd sans l’arrêter en utilisant la commande kill .

Pour voir la progression de dd une fois qu’elle est lancée, ouvrez un autre terminal et entrez:

sudo kill -USR1 $(pgrep ^dd)

Cela affichera la progression de dd dans la fenêtre du terminal dd sans interrompre le processus. Si vous êtes sur BSD ou OS X, utilisez INFO au lieu de USR1 . Le signal USR1 se terminera par dd.

Si vous souhaitez obtenir des mises à jour régulières de la progression de dd , entrez:

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

watch sondera le processus dd toutes les -n secondes ( -n5 = 5 secondes) et signalera sans l'arrêter.

Notez les guillemets simples appropriés dans les commandes ci-dessus.

Mise à jour 2016 : si vous utilisez GNU coreutils & gt; = 8.24 (par défaut dans Ubuntu Xenial 16.04), reportez-vous à la méthode 2 ci-dessous pour afficher la progression. .

Méthode 1: en utilisant pv

Installez pv et placez-le uniquement entre les commandes dd .

Note : vous ne pouvez pas l’utiliser lorsque vous avez déjà démarré dd .

De la description du package :

  

pv - Pipe Viewer - est un outil basé sur un terminal pour surveiller le   progression des données à travers un pipeline. Il peut être inséré dans n'importe quel   pipeline normal entre deux processus pour donner une indication visuelle de   à quelle vitesse les données transitent, combien de temps cela a-t-il pris,   à l'achèvement c'est, et une estimation de combien de temps ce sera jusqu'à   achèvement.

Installation

sudo apt-get install pv

Exemple

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

Sortie

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

Vous pouvez spécifier la taille approximative avec --size si vous souhaitez une estimation de temps.

Exemple Suppose qu'un disque de 2 Go est copié à partir de / dev / sdb

La commande sans pv serait:

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

Commande avec pv :

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

Sortie:

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

Autres utilisations

Vous pouvez bien sûr utiliser directement pv pour diriger la sortie vers stdout:

pv /home/user/bigfile.iso | md5sum

Sortie

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

Notez que dans ce cas, pv reconnaît automatiquement la taille.

Méthode 2: Nouvelle option status ajoutée à dd (GNU Coreutils 8.24 +)

dd dans GNU Coreutils 8.24+ (Ubuntu 16.04 et versions ultérieures) a obtenu une nouvelle option status pour afficher la progression:

exemple

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

Sortie

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

Quelques exemples d’exemples pratiques avec pv et moins de frappe ou plus de progrès que d’autres réponses:

Vous devez d’abord installer pv , avec la commande:

sudo apt-get install pv

Voici quelques exemples:

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

^{Remarque: le premier échantillon est composé de 5 caractères de moins, puis de dd if=/dev/urandom | pv | dd of=/dev/null .}

Et mon préféré pour cloner un lecteur de disque:

(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

source: lien

_{Aussi pour archiver moi-même.}

Utilisez Ctrl + Shift + T pendant que dd est en cours d'exécution, et il affichera la progression (en octets):

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)

Par souci d'exhaustivité:

La version 8.24 de coreutils GNU inclut un correctif pour dd introduisant un paramètre pour imprimer la progression.

Le commit présentant ce changement a le commentaire :

  

dd: nouveau niveau status = progrès pour imprimer des statistiques périodiquement

De nombreuses distributions, y compris Ubuntu 16.04.2 LTS , utilisent cette version.

Le meilleur est d'utiliser lien qu'il est facile d'installer via apt-get

Le statut de progression natif a été ajouté à dd !!!

La nouvelle version de Coreutils (8.24) ajoute un statut de progression à l’outil dd :

Utilisation sur Xubuntu 15.10:

Ouvrez un terminal et tapez ces commandes:

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)

Exécutez dd en tant que root:

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

Vous verrez: Octets, secondes et vitesse (octets / seconde).

Pour vérifier les versions de dd :

Native:

dd --version

Nouveau:

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

Si vous avez déjà démarré dd, et si vous écrivez un fichier tel que lors de la création d’une copie d’une clé USB sur le disque, vous pouvez utiliser la commande watch pour observer en permanence la taille du fichier de sortie .

watch ls -l /pathtofile/filename

Pour voir uniquement la taille du fichier (h-human view):

watch ls -sh /pathtofile/filename

La triade dd | pv | dd a fait en sorte que ma copie vm de 50 Go prenne 800 secondes, contre 260 secondes avec dd. Avec ce pipeline, au moins, pv n’a aucune idée de la taille du fichier d’entrée, il ne sera donc pas en mesure de vous dire à quelle distance vous vous trouvez.

J'éviterais le pv sur tout ce qui est grand, et (si j'utilisais Bash):

Contrôle-Z le processus dd

bg pour le mettre en arrière-plan. Observez que bg vous donnera un résultat comme [1] 6011 où le dernier numéro est un identifiant de processus. Alors, faites:

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

où process_id est l'ID de processus que vous avez observé. Hit Control-C quand vous voyez quelque chose comme:

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

Vous avez terminé.

Edit: Silly Systems Administrator! Automatisez votre vie, ne travaillez pas! Si j'ai un long processus de dd que je veux surveiller, voici une feuille de route qui prendra en charge toute l'enchilada pour vous; mettez tout cela sur une seule ligne:

 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

Bien sûr, vous pouvez le scripter, peut-être faire de $ 1 votre fichier d'entrée et $ 2 votre fichier de sortie. Ceci est laissé comme un exercice pour le lecteur. Notez que vous avez besoin de peu de sommeil avant que le kill ou le kill ne meurent en essayant d'envoyer un signal à dd quand il n'est pas encore prêt. Ajustez votre sommeil comme vous le souhaitez (peut-être même supprimez-le complètement).

Bash-FTW! : -)

lien

Fondamentalement:

kill -USR1 < dd pid >

Sur Ubuntu 16.04

Ubuntu 16.04 est livré avec la version dd (coreutils) 8.25 . Par conséquent, l'option status=progress est prise en charge: -)

Pour l'utiliser, ajoutez simplement status=progress avec votre commande dd .

Exemple:

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

Donne le statut en tant que

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

Le plus simple est:

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

oflag=dsync gardera votre écriture synchronisée, donc les informations de status=progress sont plus précises. Cependant, cela pourrait être un peu plus lent.

J'ai créé un wrapper bash sur dd qui utilisera pv pour afficher les progrès. Placez-le dans votre .bashrc et utilisez dd comme d'habitude:

# 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

Source:

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" "[email protected]"
        return $?
    }

    local arg arg2 infile
    local -a args
    for arg in "[email protected]"
    do
        arg2=${arg#if=}
        if [ "$arg2" != "$arg" ]
        then
            infile=$arg2
        else
            args[${#args[@]}]=$arg
        fi
    done

    "$pv" -tpreb "$infile" | "$dd" "${args[@]}"
}

J'aime vraiment ddrescue, ça marche comme dd mais ça donne des résultats et ça n'échoue pas sur les erreurs, au contraire ça a un algorithme très avancé et ça essaye vraiment de faire une copie réussie ... Il y a aussi beaucoup de GUI pour c'est

Projet: lien

Wikipedia: lien

Aujourd'hui, j'ai été un peu frustré d'essayer de lancer kill dans une boucle alors que dd était en cours d'exécution, et a proposé cette méthode pour les exécuter en parallèle, facilement:

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

Maintenant, utilisez simplement vdd partout où vous utilisez normalement dd (il passe tous les arguments directement) et vous obtenez un rapport d'avancement imprimé toutes les 5 secondes.

Le seul inconvénient est que la commande ne retourne pas immédiatement lorsque dd se termine; Il est donc possible que cette commande vous fasse attendre 5 secondes supplémentaires après le retour de dd avant qu'elle ne soit détectée et terminée.

Comme mentionné ci-dessus, au moins avec le 'dd' de GNU coreutils, ou busybox, il répondra à un signal USR1 en imprimant des informations de progression à stderr.

J'ai écrit un petit script de wrapper pour dd qui montre un bon indicateur de pourcentage complet, et essaie de ne pas interférer avec le processus ou le mode de fonctionnement de dd. Vous pouvez le trouver sur github:

lien

Malheureusement, cette astuce SIGUSR1 ne fonctionne qu'avec le mode GNU dd (du paquet coreutils) ou le mode 'dd' de busybox avec cette fonctionnalité spécifique activée au moment de la compilation. Il ne fonctionne pas avec le stock "dd" inclus avec la plupart des systèmes BSD, y compris FreeBSD et OS X ...: (

Celui-ci force dd à fournir des statistiques toutes les 2 secondes, ce qui est la valeur par défaut pour watch:

watch killall -USR1 dd

Pour passer de toutes les 2 secondes à toutes les 5 secondes, ajoutez l’option -n 5 comme ceci:

watch -n 5 killall -USR1 dd

Utilisez l'option status=progress pour connaître l'avancement pendant le transfert.

De plus, conv=fsync affichera des erreurs d'E / S.

Exemple:

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

Vous pouvez suivre la progression de tout programme coreutils en utilisant progress - Coreutils Progress Viewer .

Il peut surveiller:

cp mv dd chat tar rsync grep fgrep egrep trier md5sum sha1sum sha224sum sha256sum sha384sum sha512sum adz gzip gunzip bzip2 bunzip2 xz unzz lzma unlzma 7z 7za zcat bzcat

Vous pouvez consulter la page de manuel

Vous pouvez l’utiliser dans une fenêtre de terminal séparée pendant que la commande est en cours d’exécution ou la lancer avec la commande dd:

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

Ici, & lance la première commande et continue immédiatement au lieu d'attendre la fin de la commande.

La commande de progression est lancée avec: -m pour attendre la fin du processus surveillé, -p pour surveiller un pid donné et $! est le dernier pid de commande.

Si vous lancez dd avec sudo, vous devez aussi faire des progrès:

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