J'ai un disque dur rempli de zéros.
Comment vérifier si tous les bits du disque dur sont des zéros en utilisant bash?
hard-drive
bash
ubuntu-12.10
gkfvbnhjh2
la source
la source
Réponses:
od
remplacera les exécutions de la même chose*
, vous pouvez donc facilement l'utiliser pour rechercher des octets non nuls:la source
| head
à la fin de cela, de sorte que s'il s'avère que le lecteur n'est pas mis à zéro, il s'arrête après avoir produit juste assez de sortie pour montrer le fait, au lieu de vider le lecteur entier à l'écran.J'ai écrit un petit programme C ++ pour le faire, source disponible ici .
Pour le construire:
Pour l'exécuter:
Il affichera la position et la valeur de tout octet différent de zéro. Vous pouvez rediriger cette sortie vers un fichier avec
>
, par exemple:Vous voudrez peut-être essayer de changer
BUFFER_SIZE
pour une meilleure efficacité. Je ne sais pas quelle valeur optimale pourrait être. Notez que cela affecte également la fréquence d'impression de la progression, ce qui affectera quelque peu la vitesse (la sortie d'impression vers la console est lente ). Ajouter2>/dev/null
pour se débarrasser de la sortie de progression.Je suis conscient que cela n'utilise pas bash standard, ni même des commandes intégrées, mais cela ne devrait pas nécessiter de privilèges supplémentaires. La solution de @Hennes est encore plus rapide (je n'ai vraiment rien optimisé - c'est la solution naïve); cependant, ce petit programme peut vous donner une meilleure idée du nombre d'octets manquants dans votre essuie-glace et de son emplacement. Si vous désactivez la sortie de progression, elle sera toujours plus rapide que la plupart des disques durs grand public peuvent lire (> 150 Mo / s), ce n'est donc pas un gros problème.
Une version plus rapide avec une sortie moins verbeuse est disponible ici . Cependant, elle est encore un peu plus lente que la solution @Hennes. Celui-ci, cependant, se fermera sur le premier caractère non nul qu'il rencontre, il est donc potentiellement beaucoup plus rapide s'il y a un non nul près du début du flux.
Ajout de la source au message pour garder la réponse mieux autonome:
la source
iszero /dev/sda
plutôt qu'en exigeant qu'il soit canalisé avec quelque chose commeiszero < /dev/sda
?int main(int argc, char *argv[])
et puisFILE* file = fopen(argv[1], "r");
. Fait correctement, il comprendrait la vérification si l'argument existe réellement, la vérification des erreurs réussie (faites uneferror
vérification supplémentaire après lefopen
), etc., mais trop de problèmes pour un programme jetable.gcc
n'est pas nécessairement disponible sur toutes les distributions Linux sans retirer des packages supplémentaires. Là encore, numpy ne fait pas non plus partie des packages Python standard ...-O3
et-march=native
vous pourriez voir des accélérations; cela devrait garantir que GCC active la vectorisation automatique et utilise le meilleur disponible pour votre CPU actuel (AVX, SSE2 / SSE3, etc.). Parallèlement à cela, vous pouvez jouer avec la taille du tampon; différentes tailles de mémoire tampon peuvent être plus optimales avec des boucles vectorisées (je jouerais avec 1 Mo +, la valeur actuelle est de 1 Ko).@Bob
) dans le chat: chat.stackexchange.com/rooms/118/root-accessÉlargissant la réponse de Gordon,
pv
fournit une indication de la longueur du processus:la source
Cela semble une mauvaise solution inefficace, mais si vous ne devez vérifier qu'une seule fois:
dd if=/dev/sdX | tr --squeeze-repeats "\000" "T"
Utilisation de dd pour lire à partir du disque
sdX
. (remplacez le X par le lecteur à partir duquel vous voulez lire),puis traduisez tous les octets zéro non imprimables en quelque chose que nous pouvons gérer.
Ensuite, soit nous comptons les octets que nous pouvons gérer et vérifions s'il s'agit du bon nombre (à utiliser
wc -c
pour cela), soit nous ignorons le comptage et utilisons le-s
ou--squeeze-repeats
pour compresser toutes les occurrences multiples en un seul caractère.Il
dd if=/dev/sdX | tr --squeeze-repeats "\000" "T"
ne faut donc imprimer qu'un seul T.Si vous voulez le faire régulièrement, vous voulez quelque chose de plus efficace.
Si vous ne voulez faire cela qu'une seule fois, alors ce kludge peut vérifier que votre essuie-glace normal fonctionne et que vous pouvez lui faire confiance.
la source
Pour vérifier uniquement, vous verrez tous les blocs qui ne correspondent pas répertoriés
Ou utilisez des badblocks pour les écrire ainsi que pour vérifier:
Le test destructif par défaut est mon effacement sécurisé de choix
Si quelqu'un peut récupérer quoi que ce soit après avoir rempli le lecteur avec une alternance de 0 et de 1, alors leur complément, puis tous les 1, puis tous les 0, avec chaque passe vérifiée, cela a fonctionné, bonne chance à eux!
Effectue également une bonne vérification de pré-déploiement sur les nouveaux disques
pour d'autres options
Je ne dis pas que c'est rapide, mais ça marche ...
la source
Le meilleur des deux mondes. Cette commande sautera les secteurs défectueux:
Utilisez
kill -USR1 <pid of dd>
pour voir les progrès.la source
Il y a quelque temps, j'étais curieux de savoir
AIO
. Le résultat a été un exemple de programme de test qui vérifie les secteurs (blocs de 512 octets) qui le sontNUL
. Vous pouvez voir cela comme une variante d'un détecteur de régions de fichiers épars . Je pense que la source dit tout.NUL
sortie, cela ressemble0000000000-eof
. Notez qu'il y a une astuce dans le programme, fonctionfin()
n'est pas appelée à la ligne 107 pour donner la sortie affichée.AIO
n'est pas aussi simple que d'autres façons,AIO
c'est probablement le moyen le plus rapide de garder un lecteur occupé à lire , car laNUL
comparaison est effectuée pendant la lecture du bloc de données suivant. (Nous pourrions extraire quelques millisecondes supplémentaires en faisant un chevauchementAIO
, mais je ne pense vraiment pas que cela vaut la effort.)true
si le fichier est lisible et que tout a fonctionné. Il ne revient pasfalse
si le fichier est nonNUL
.NUL
il fonctionne toujours, car les tampons de mémoire contiennent déjàNUL
. Si quelqu'un pense que cela a besoin d'un correctif, à la ligne 95, lememcmp(nullblock, buf+off, SECTOR)
pourrait lirememcmp(nullblock, buf+off, len-off<SECTOR : len-off : SECTOR)
. Mais la seule différence est que le "rapport final" est peut-être un peu aléatoire (pas pour un fichier qui l'est entièrementNUL
).memcmp()
corrige également un autre problème sur les plates-formes, qui neNUL
alloc()
réduisent pas la mémoire, car le code ne le fait pas. Mais cela ne peut être vu que par des fichiers de moins de 4 Mo, mais c'estchecknul
probablement une surpuissance pour une si petite tâche;)HTH
la source
Je voulais publier cette solution intelligente à partir d'une question similaire mais antérieure, publiée par un utilisateur qui ne s'est pas connecté depuis un certain temps:
la source