Comment surveillez-vous les progrès du jj?
dd est 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 commande dd, 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?
De HowTo: Surveiller la progression de jj
Vous pouvez surveiller la progression de dd sans l'arrêter à l'aide de la commande kill.
Pour voir la progression de dd une fois qu'il est en cours d'exécution, ouvrez un autre terminal et entrez:
Sudo kill -USR1 $(pgrep ^dd)
Cela affichera dd progress dans la fenêtre de terminal dd sans interrompre le processus. Si vous utilisez BSD ou OS X, utilisez INFO au lieu de USR1. Le signal USR1 mettra fin à 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 analysera le processus dd toutes les -n secondes (-n5 = 5 secondes) et fera un rapport sans l'arrêter.
Notez les guillemets simples appropriés dans les commandes ci-dessus.
Mise à jour 2016 : Si vous utilisez GNU coreutils> = 8.24 (valeur par défaut à partir de Ubuntu Xenial 16.04), voir la méthode 2 ci-dessous pour une autre façon d'afficher la progression.
Méthode 1: en utilisant pv
Installez pv et placez-le entre les commandes d'entrée/sortie uniquement dd.
Remarque : vous ne pouvez pas l'utiliser lorsque vous avez déjà lancé dd.
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 n’importe quel pipeline normal entre deux processus pour donner une indication visuelle de la vitesse à laquelle les données transitent, de la durée de leur achèvement, de son achèvement et de son estimation.
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 --size si vous souhaitez une estimation du temps.
Exemple En supposant qu'un disque de 2 Go soit 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 pv directement pour diriger le résultat 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 in GNU Coreutils 8.24+ (Ubuntu 16.04 et plus récente) a reçu 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'utilisations pratiques avec pv et moins de frappe ou plus de progrès que d'autres réponses:
Vous devez d’abord installer pv à l’aide de la commande suivante:
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 exemple contient 5 caractères moins la saisie, puis 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.
Utilisation Ctrl+Shift+T pendant que dd est en cours d’exécution, la progression (en octets) sera affichée:
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 du GNU coreutils inclut un correctif pour dd introduisant un paramètre permettant d’imprimer la progression.
The commit introduire ce changement a le commentaire:
dd: nouveau status = progress niveau pour imprimer les statistiques périodiquement
De nombreuses distributions, y compris Ubuntu 16.04.2 LTS utilisent cette version.
Le meilleur est d'utiliser http://dcfldd.sourceforge.net/ il est facile d'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'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:
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 trio dd | pv | dd a créé une copie de 50 Go par vm en 800 secondes au lieu de 260 secondes avec dd seulement. 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 bénéficiez d'un avantage en termes de vitesse de Nice:
Je voudrais éviter pv sur quelque chose de grand, et (si vous utilisez Bash):
Control-Z le processus DD
bg pour le mettre en arrière-plan. Observez que bg vous donnera une sortie telle que [1] 6011 où 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 l’enchilada entière 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 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=dsync maintiendra votre écriture synchronisée afin que les informations de status=progress soient plus précises. Cependant, cela pourrait être un peu plus lent.
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 de
1282846183 bytes (1.2 GiB, 1.1 GiB) copied, 14.03 s, 101.9 MB/s
Utilisez l'option status=progress pour obtenir l'avancement pendant le transfert.
De plus, conv=fsync affichera 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éé bash wrapper sur dd qui utilisera pv pour afficher les progrès. Mettez-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
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[@]}"
}
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
Donc aujourd'hui, je suis un peu frustré d'essayer d'exécuter kill dans une boucle alors que dd était en cours d'exécution, 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 simplement vdd partout où vous utiliseriez normalement dd (il transmet tous les arguments 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 une fois que dd est terminé. il est donc possible que cette commande puisse vous faire attendre 5s de plus après que dd soit revenu avant de s'en rendre compte.
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 du GNU coreutils comprend un patch pour dd introduisant un paramètre permettant d’imprimer la progression.
Cela peut être le cas, mais CentOS peut 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.
Ceci 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 sur stderr.
J'ai écrit un petit script wrapper pour dd qui affiche un indicateur de pourcentage de complétion de Nice 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 suivre la progression de n’importe quel programme coreutils à l’aide de progress - Coreutils Progress Viewer.
Il peut surveiller:
cp mv dd tar cat rsync grep fgrep egrep coupé trier md5sum sha1sum sha224sum sha256sum sha384sum sha512sum adb gzip gunzip bzip2 bzip2 gpg
Vous pouvez voir le manpage
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: -m et attend donc la fin du processus surveillé, -p pour surveiller un pid donné et $! est le dernier pid de la commande.
Si vous publiez dd avec Sudo, vous devez également 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