dd
est 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 dd
il 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
expr
octets, remplaçant ibs=
et obs=
. Si aucune conversion autre que sync
, noerror
et notrunc
n'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 ibs
et obs
sont définis ensemble, bs
alors ibs
prioritaire - mais sinon, si vous êtes spécifique, alors soit obs
ou le cbs
fait.
Voici un exemple dans lequel ibs
est le plus important. Vous pourriez faire quelque chose comme ça si vous vouliez suivre la vitesse à laquelle la /dev/random
piscine 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 dd
les sync
blocs 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, dd
l'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 dd
pour 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 dd
tamponnerait 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 dd
peut 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 dd
doit faire pour le faire.
Et c'est ainsi que vous pouvez utiliser dd
pour lire de manière fiable des tuyaux ou d'autres types de fichiers spéciaux - avec juste un peu de calcul.
/dev/random
se 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/urandom
pour une valeur "aléatoire" moins aléatoire, soit vérifier votre pool d'entropie (en boucle, et attendre au besoin) ...