ddest conçu pour le blocage - c'est généralement le meilleur outil à votre disposition pour lire à partir d'entrées de taille variable si vous en avez besoin immédiatement car ddil ne tamponnera pas les lectures en cours dans un futur futur write() (sauf si vous le configurez de manière très explicite de cette façon avec des obs plus grandes que ibs) , mais va à la place write()tout ce qu'il lit dès qu'il read()est (et éventuellement le traite) .
Voici quelques définitions importantes :
ibs=expr
- Spécifiez la taille du bloc d'entrée, en octets, par (la valeur par défaut est 512) .
expr
obs=expr
- Spécifiez la taille du bloc de sortie, en octets, par (la valeur par défaut est 512) .
expr
bs=expr
- Définissez les tailles des blocs d'entrée et de sortie sur
exproctets, remplaçant ibs=et obs=. Si aucune conversion autre que sync, noerroret notruncn'est spécifiée, chaque bloc d'entrée doit être copié dans la sortie en tant que bloc unique sans agréger les blocs courts.
Donc, vous voyez, quand ibset obssont définis ensemble, bsalors ibsprioritaire - mais sinon, si vous êtes spécifique, alors soit obsou le cbsfait.
Voici un exemple dans lequel ibsest le plus important. Vous pourriez faire quelque chose comme ça si vous vouliez suivre la vitesse à laquelle la /dev/randompiscine s'est remplie ...
dd "ibs=$size" conv=sync "count=$lmt" \
if=/dev/random of="$somefile"
Tant que if=la cible de 'est lisible, cela se traduira toujours par le même fichier de sortie de taille, car ddles syncblocs seront lus sur les valeurs nulles. En d'autres termes, si dd read()s pour un bloc d'entrée de $((size=10)) $((count=5))temps et que le read()fichier renvoie 2 octets, puis 8 octets, puis 12 octets, puis 2 octets, puis 4 octets, ddécrira dans son fichier de sortie quelque chose comme
2 read bytes 8NULs \
8 read bytes 2NULs \
10 read bytes 0NULs \
4 read bytes 6NULs \
4 read bytes 6NULs
... car dd, par défaut, ne tarde pas . Donc, si vous avez besoin de suivre en continu et de délimiter les écritures d'un autre processus, ddl'outil est pour vous.
Si vous écrivez simplement une certaine quantité de données dans un fichier normal, contrairement à d'autres déclarations faites ici, vous pouvez également l'utiliser ddpour cela - et assez facilement - mais vous en aurez besoin de plusieurs et d'un facteur de blocage fiable .
Par exemple, si vous l'avez fait:
{ dd ibs="$size" obs="${size}x$block_factor" |
dd bs="${size}x$blockfactor" "count=$lmt"
} <infile >outfile
... le premier ddtamponnerait autant de ibs="$size"blocs d'entrée que nécessaire pour remplir au moins un obs="${size}x$block_factor"bloc de sortie pour chacun write()du tuyau entre celui-ci et le second dd. Cela signifie que le second ddpeut limiter la sortie de manière fiable avec count="$lmt"car tous les write()s que le premier fait correspondront à sa taille de bloc d'E / S - quel que soit le nombre de read()s que le premier dddoit faire pour le faire.
Et c'est ainsi que vous pouvez utiliser ddpour lire de manière fiable des tuyaux ou d'autres types de fichiers spéciaux - avec juste un peu de calcul.
/dev/randomse bloquera s'il n'y a pas assez d'entropie disponible pour générer le nombre de chiffres souhaité. il faut simplement du temps pour rassembler cette quantité de "randomité" aléatoire de haute qualité ... Soit utiliser/dev/urandompour une valeur "aléatoire" moins aléatoire, soit vérifier votre pool d'entropie (en boucle, et attendre au besoin) ...