Comment vérifier l'état physique d'une clé USB sous Linux ?

Il n'y a aucun moyen d'interroger une clé USB pour obtenir des paramètres de type SMART ; Je ne connais aucune clé USB qui permette de le faire. même via un logiciel propriétaire disponible publiquement.  Le mieux que vous puissiez faire est de vérifier que vous pouvez lire et écrire avec succès sur l'ensemble du périphérique en utilisant la commande badblocks .

https://en.wikipedia.org/wiki/Badblocks

Vous voulez spécifier l'un des tests d'écriture, qui effacera toutes les données sur la clé ; faites d'abord une sauvegarde.

Trouvez le dispositif en regardant dmesg après avoir branché la clé USB ; vous verrez un nom de périphérique (très probablement sd_<letter>_ , par exemple, sdc , sdd etc.) et des informations sur le fabricant.  Assurez-vous que vous utilisez le bon appareil !

Si la clé est formatée avec un système de fichiers valide, vous devrez peut-être d'abord la démonter (avec la commande  umount commande).

Exemple de syntaxe, pour une clé USB énumérée comme suit /dev/sdz , la sortie d'informations sur la progression, avec un destructeur de données test d'écriture et le journal des erreurs écrit dans  usbstick.log :

sudo badblocks -w -s -o usbstick.log /dev/sdz

Vous devrez ensuite repartitionner et reformater la clé, en supposant qu'elle réussisse ; ce test effacera tout sur la clé. Tout échec indique une défaillance du contrôleur de mémoire du périphérique, ou qu'il n'a plus de blocs de rechange pour remapper les blocs défaillants. Dans ce cas, on ne peut faire confiance à aucune zone du périphérique.

Via [ubuntu] Erreur de vérification d'une clé USB J'ai finalement trouvé ceci, qui pourrait être utile :

• http://oss.digirati.com.br/f3/ "F3 - une alternative à h2testw"

Je suis arrivé sur les blogs Fight Flash Fraud et SOSFakeFlash, qui recommandent le logiciel H2testw (voir ici ou ici) pour tester les mémoires flash. J'ai téléchargé H2testw et j'ai trouvé deux problèmes avec ce logiciel : (1) il est pour Windows seulement, et (2) il n'est pas open source. Cependant, son auteur a eu la gentillesse d'inclure un fichier texte qui explique ce qu'il fait ; cette page est consacrée à mon implémentation GPLv3 de cet algorithme.
Mon implémentation est simple et fiable, et je ne sais pas exactement comment F3 se compare à H2testw puisque je n'ai jamais utilisé H2testw. J'appelle mon implémentation F3, qui est l'abréviation de Fight Flash Fraud, ou Fight Fake Flash.

Addendum par @pbhj : F3 est dans les dépôts Ubuntu. Il a deux parties, f3write écrit des fichiers de 1GB sur le périphérique et f3read tente de les lire ensuite. De cette façon, la capacité et l'aptitude à écrire et à lire efficacement des données sont testées.

Cela dépend du mode de défaillance, je suppose. Ils sont bon marché pour une raison.

En tant que périphérique USB, l'observation du bus via le gestionnaire de périphériques sous Windows ou la sortie de dmesg sous Linux vous dira si le périphérique est même reconnu comme étant branché. Si ce n'est pas le cas, c'est que le contrôleur embarqué ou les connexions physiques sont défectueux.

Si le périphérique est reconnu comme étant branché, mais n'est pas identifié comme un contrôleur de disque (et je ne sais pas comment cela peut arriver, mais...) alors le contrôleur est fichu.

S'il est reconnu comme un lecteur de disque, mais que vous ne pouvez pas le monter, vous pouvez peut-être le réparer via fdisk et réécrire la table de partition, puis créer un autre système de fichiers.

Si vous cherchez l'équivalent de S.M.A.R.T. alors vous ne le trouverez pas. Les contrôleurs de disques durs sont bon marché. Il s'agit de stockage de base, et ils ne sont pas censés avoir les failsafes normaux et l'intelligence que les disques modernes ont.

En chemin vers aujourd'hui, ce fil de discussion a soulevé quelques questions.

- Combien de temps cela va-t-il prendre ? (sous-entendu par la discussion sur le fait de le laisser fonctionner pendant la nuit).

Je suis actuellement en train de tester un Sandisk 128G USB 3.0 en utilisant sudo badblocks -w -s -o Il est connecté à ma carte PCIe USB 3/USBC dans un vieil Athlon 64x2. Donc, USB3 vers USB3 sur PCIe devrait être assez rapide.

Voici la ligne de commande de ma console à 33% d'achèvement :

Testing with pattern 0xaa: 33.35% done, 49:47 elapsed. (0/0/0 errors)

et encore plus tard :

Testing with pattern 0xaa: 54.10% done, 1:17:04 elapsed. (0/0/0 errors)

Ensuite, il y a eu ce segment :

Reading and comparing: 43.42% done, 2:23:44 elapsed. (0/0/0 errors)

Ce processus se répète avec oxaa, puis 0x55, 0xff, et enfin 0x00.

ArchLinux a fait une déclaration sans réserve :

For some devices this will take a couple of days to complete.

N.B. : Les tests ont commencé vers 20 h 30, et se sont terminés avant 8 h 45 le jour suivant, pour s'achever à peu près à la même heure. 12 heures pour ma situation .

- Les tests destructifs ne sont pas la seule méthode possible.

Wikipedia propose cette déclaration :

badblocks -nvs /dev/sdb This would check the drive "sdb" in non-destructive read-write mode and display progress by writing out the block numbers as they are checked.

La page de manuel de ma distribution actuelle confirme que le -n n'est pas destructif.

-n Use non-destructive read-write mode. By default only a non- destructive read-only test is done.

Et enfin que ça n'en vaut pas la peine. déclaration.

Pour résumer, en se basant sur la situation des milliards de sites de mémoire dans une puce flash, une défaillance est une cellule qui a déjà été écrite et effacée des dizaines de milliers de fois, et qui est maintenant défaillante. Et lorsqu'un test montre qu'une cellule est défaillante, rappelez-vous que chaque fichier ajouté et effacé fait tourner ces cycles.

L'idée est que lorsqu'une cellule tombe en panne, de nombreuses autres cellules atteignent également le même point de défaillance. Une cellule est tombée en panne aujourd'hui, mais vous l'utilisez normalement pendant un certain temps encore, puis 3 autres cellules tombent en panne, puis 24 autres, puis 183, et avant que vous ne le sachiez, la matrice de mémoire est criblée de points faibles. Il n'y a qu'un nombre limité de cellules qui peuvent mourir avant que votre capacité utilisable ne commence à diminuer, et finalement à diminuer rapidement. Comment saurez-vous que d'autres cellules sont défaillantes ? Donc, les messages ici protègent vos données en disant qu'une fois que vous avez une cellule défectueuse, vous êtes pratiquement fini en ce qui concerne le stockage digne de confiance. Votre utilisation peut encore vous donner quelques mois.

Ce sont vos données.

HTH

De nombreuses défaillances sont soit complètes, soit permettent à un site de prendre en charge plusieurs sites. J'ai écrit un petit programme de lecture et d'écriture aléatoire qui utilise un nombre premier comme générateur de nombres pseudo-aléatoires, à la fois pour les motifs et les adresses. Les lectures sont décalées par rapport aux écritures d'un nombre suffisant de pages pour m'assurer que je ne teste pas le cache RAM sur le système. Il n'est pas encore paramétré, juste configuré pour un dispositif de 64G sur mon système avec 8G de RAM. N'hésitez pas à critiquer, à paramétrer, à le rendre plus intelligent.

C'est une vérification puissante et plus rapide que de faire chaque octet de bas en haut, mais c'est aussi un grand générateur de swap (il fait rouler presque tout le reste). J'ai temporairement mis le swapiness à 1 et il est devenu plus lent mais plus tolérable pour les autres applications. Tout conseil sur la façon d'optimiser le swapout serait également apprécié :

$ sudo ksh -c 'echo 1 > /proc/sys/vm/swappiness'

$ cat mysrc/test64g.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>

int main( int argc, char **argv ){

        long long int mask = 0xFFFFFFFF8L ;    // 64Gb word
        long long int stag = 8413257 ;  // 8G / 1021
        long long int inc = 1021L ;     // prime < 1024

        long long int w_addr = 0L ;
        long long int r_addr = 0L ;
        long long int w_ct = 0L ;
        long long int r_ct = 0L ;
        long long int w_patt = 0xFEDCBA9876543210L ;
        long long int r_patt = 0xFEDCBA9876543210L ;
        long long int r_buf ;
        int fd, ret ;

        if ( argc < 2
          || argv[1] == NULL
          || 0 > ( fd = open( argv[1], O_RDWR ))){
                printf( "Fatal: Cannot open file $1 for RW.\n" );
                exit( 1 );
        }

        while ( 1 ){
                if ( (off_t)-1 == lseek( fd, w_addr & mask, SEEK_SET )){
                        printf( "Seek to %llX\n", w_addr & mask );
                        perror( "Fatal: Seek failed" );
                        exit( 2 );
                }

                if ( 8 != ( ret = write( fd, (void*)&w_patt, 8 ))){
                        printf( "Seek to %llX\n", w_addr & mask );
                        perror( "Fatal: Write failed" );
                        exit( 3 );
                }

                w_ct++ ;
                w_addr += inc ;
                w_patt += inc ;

                if ( ( w_ct - r_ct ) < stag ){
                        continue ;
                }

                if ( (off_t)-1 == lseek( fd, r_addr & mask, SEEK_SET )){
                        printf( "Seek to %llX\n", r_addr & mask );
                        perror( "Fatal: Seek failed" );
                        exit( 4 );
                }

                if ( 8 != ( ret = read( fd, (void*)&r_buf, 8 ))){
                        printf( "Seek to %llX\n", w_addr & mask );
                        perror( "Fatal: Read failed" );
                        exit( 5 );
                }

                if ( ( ++r_ct & 0XFFFFF ) == 0 ){
                        printf( "Completed %lld writes, %lld reads.\n", w_ct, r_ct );
                }

                if ( r_buf != r_patt ){
                        printf( "Data miscompare on read # %lld at address %llX:\nWas: %llX\nS/B: %llX\n\n", r_ct, r_addr & mask, r_buf, r_patt );
                }

                r_addr += inc ;
                r_patt += inc ;
        }
}