ddest une merveille. Il vous permet de dupliquer un disque dur sur un autre, de mettre complètement zéro un disque dur, etc. Mais une fois que vous lancez une ddcommande, rien ne vous indique sa progression. Il reste juste là au curseur jusqu'à la fin de la commande. Alors, comment surveiller les progrès de dd?

Mise à jour 2016 : Si vous utilisez GNU coreutils> = 8.24 (par défaut à partir de Ubuntu Xenial 16.04), reportez-vous à la méthode 2 ci-dessous pour obtenir un autre moyen d'afficher la progression.

Méthode 1: en utilisant pv

Installez-le pvet mettez-le entre les commandes d'entrée / sortie uniquement dd.

Remarque : vous ne pouvez pas l'utiliser lorsque vous avez déjà commencé dd.

De la description du paquet :

pv- Pipe Viewer - est un outil basé sur un terminal permettant de surveiller la progression des données via un pipeline. Il peut être inséré dans tout pipeline normal entre deux processus pour donner une indication visuelle de la vitesse à laquelle les données transitent, de la durée de leur acheminement, de son achèvement et de son estimation, ainsi que de sa durée approximative.

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 le --sizesi vous voulez une estimation du temps.

Exemple En supposant qu'un disque de 2 Go soit copié à partir de / dev / sdb

Commande sans pvserait:

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 pvdirectement 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, pvreconnaît automatiquement la taille.

Méthode 2: nouvelle statusoption ajoutée à dd(GNU Coreutils 8.24+)

dddans GNU Coreutils 8.24+ (Ubuntu 16.04 et plus récente) a une nouvelle statusoption 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

De HowTo: Surveiller la progression de jj

Vous pouvez surveiller la progression de dd sans l'arrêter à l'aide de la killcommande.

Pour voir la progression de ddson exécution, ouvrez un autre terminal et entrez:

sudo kill -USR1 $(pgrep ^dd)

Cela affichera la ddprogression dans la ddfenêtre du terminal sans interrompre le processus. Si vous utilisez BSD ou OS X, utilisez INFOplutôt que USR1. Le USR1signal fin dd.

Si vous souhaitez recevoir des mises à jour régulières sur les ddprogrès, entrez:

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

watchanalysera le ddprocessus toutes les -n secondes ( -n5= 5 secondes) et signalera sans l’arrêter.

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

Quelques exemples d’utilisations pratiques avec pvmoins de dactylographie ou plus de progrès que d’autres réponses:

Tout d'abord, vous devrez 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 contient 5 caractères moins la frappe dd if=/dev/urandom | pv | dd of=/dev/null.}

Et mon préféré pour cloner un lecteur de disque (remplacez X par des lettres de lecteur):

(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

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

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

Utilisez Ctrl+ Shift+ tant Tqu’il ddest 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 GNU coreutils inclut un correctif pour dd introduisant un paramètre permettant d’imprimer la progression.

Le commit introduisant ce changement a le commentaire suivant:

dd: nouveau statut = niveau de progression pour imprimer les statistiques périodiquement

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

Le mieux est d'utiliser http://dcfldd.sourceforge.net/, il est facile à installer via apt-get

Le statut de progression natif a été ajouté au jj !!!

La nouvelle version de Coreutils (8.24) ajoute un statut de progression à l' ddoutil:

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écuter en ddtant 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:

Originaire de:

dd --version

Nouveau:

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

Si vous avez déjà lancé dd et si vous écrivez un fichier, par exemple lors de la création d'une copie d'une clé USB sur disque, vous pouvez utiliser la commande watch pour observer en permanence la taille du fichier de sortie afin de voir les modifications et d'estimer l'achèvement.

watch ls -l /pathtofile/filename

Pour ne voir que la taille du fichier (vue h-humaine):

watch ls -sh /pathtofile/filename

Le dd | pv | ddtrio a fait ma copie de 50 Go vm prendre 800 secondes, par opposition à 260 secondes en utilisant seulement dd. Avec ce pipeline, au moins, pv n'a aucune idée de la taille du fichier d'entrée et ne peut donc pas vous dire jusqu'à quel point vous êtes, il n'y a donc aucun inconvénient à le faire comme suit, et vous obtenez un bel avantage en termes de vitesse:

Je voudrais éviter pv sur quelque chose de grand, et (si vous utilisez Bash):

Control-Z le processus DD

bgpour le mettre en arrière-plan. Observez que vous bgobtiendrez une sortie comme [1] 6011où ce dernier numéro est un identifiant de processus. Alors faites:

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

où id_processus est l'identificateur de processus que vous avez observé. Appuyez sur Control-C lorsque 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: Administrateur de systèmes stupide! Automatise ta vie, ne travaille pas! Si j'ai un long processus que je veux surveiller, voici un guide qui se chargera de 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

Vous pouvez, bien sûr, le scripter, peut-être créer $ 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 ce peu de sommeil avant le kill ou le kill peut mourir 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-vous complètement le deuxième sommeil).

Bash- FTW! :-)

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

Fondamentalement:

kill -USR1 < dd pid >

Le plus simple est:

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

oflag=dsyncmaintiendra votre écriture synchronisée afin que les informations de status=progresssoient plus précises. Cependant, cela pourrait être un peu plus lent.

Sur Ubuntu 16.04

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

Pour l'utiliser, il suffit d'ajouter status=progressavec votre ddcommande.

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 de

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

Utilisez l'option status=progresspour obtenir l'avancement pendant le transfert.

En outre, conv=fsyncaffichera les erreurs d'E / S.

Exemple:

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

J'aime beaucoup ddrescue, cela fonctionne comme dd mais donne une sortie et n’échoue pas sur les erreurs, au contraire il a un algorithme très avancé et essaie vraiment de faire une copie réussie ... Il y a aussi beaucoup d’interfaces graphiques pour cela.

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

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

J'ai créé le wrapper bash ddqui servira pvà montrer les progrès. Mettez-le dans votre .bashrcet utilisez ddcomme 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

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

Alors aujourd’hui, j’étais un peu frustré d’essayer de courir killen boucle pendant que je ddcourais, et j’ai trouvé cette méthode pour les exécuter en parallèle, facilement:

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

Maintenant, utilisez vddn’importe où vous le feriez normalement dd(tous les arguments sont passés directement) et vous obtiendrez un rapport d’avancement imprimé toutes les 5 secondes.

Le seul inconvénient est que la commande ne retourne pas immédiatement lorsque dd est terminé; il est donc possible que cette commande vous laisse attendre 5s de plus après que dd soit revenu avant de s'en rendre compte.

Celui-ci oblige dd à fournir des statistiques toutes les 2 secondes, 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

Juste au cas où quelqu'un de CentOS Land trouverait ce fil ...

L'option 'status = progress' fonctionne avec CentOS 7.5 et 7.6

La réponse ci-dessus de @davidDavidson implique que la fonctionnalité a été ajoutée récemment dans Coreutils 8.24.

La version 8.24 de GNU coreutils comprend un patch pour dd introduisant un paramètre permettant d’imprimer la progression.

Cela peut être le cas, mais CentOS pourrait ne pas suivre le même schéma de gestion de versions.

La version de Coreutils fournie avec CentOS 7.6.1810 est la suivante:

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

Et la version de dd installée est la suivante:

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

Cela montre les versions 8.22 .

Cependant, j'ai testé le 'status = progress' avec dd sur CentOS 7.5 et CentOS 7.6 (les deux avec la version 8.22 de Coreutils) et tout fonctionne correctement.

Je ne sais pas pourquoi RedHat a choisi d’utiliser une version aussi ancienne de Coreutils, mais la fonctionnalité existe avec la version 8.22.

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 affiche un indicateur de pourcentage complet et tente de ne pas interférer avec le processus ou le mode de fonctionnement de dd. Vous pouvez le trouver sur github:

http://github.com/delt01/dd_printpercent

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

Vous pouvez regarder la progression de n’importe quel programme coreutils en utilisant progress - Coreutils Progress Viewer.

Il peut surveiller:

cp mv dd tar chat rsync grep fgrep egrep coupe trier md5sum sha1sum sha224sum sha256sum sha384sum sha512sum adb gzip gunzip

Vous pouvez voir la page de manuel

Vous pouvez l'utiliser dans une fenêtre de terminal séparée pendant l'exécution de la commande ou le lancer avec la commande dd:

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

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

La commande progress est lancée avec: -mafin qu’elle attende jusqu’à la fin du processus surveillé, -pelle surveille un pid donné et $!est la dernière commande pid.

Si vous publiez dd avec sudo, vous devez aussi progresser:

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