¿Cómo verificar el estado físico de una memoria USB en Linux?

¿Cómo verificar el estado de salud de una memoria USB?

¿Cómo sé que un USB está roto sin posibilidad de reparación o reparable?

No hay forma de consultar una memoria USB para parámetros similares a SMART; No conozco ningún dispositivo de memoria que lo permita, incluso a través de un software propietario disponible públicamente. Lo mejor que puede hacer es verificar que puede leer con éxito + escribir en todo el dispositivo usando badblocks.

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

Desea especificar una de las pruebas de escritura, que borrará todos los datos en el dispositivo; haga una copia de seguridad primero.

Encuentre el dispositivo mirando dmesgdespués de enchufar el dispositivo USB; verá un nombre de dispositivo (muy probablemente sd_, es decir, sdc, sdd, etc.) e información del fabricante. ¡Asegúrate de estar usando el dispositivo adecuado!

Si el dispositivo está formateado con un sistema de archivos válido, es posible unmountque primero tenga que hacerlo.

Ejemplo de sintaxis, para un dispositivo USB enumerado como / dev / sdz, que genera información de progreso, con una prueba de escritura destructiva de datos y un registro de errores escrito en usbstick.log:

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

Tendrá que volver a particionar y formatear el palo después, suponiendo que pase; Esta prueba borrará todo en el palo. Cualquier falla indica una falla en el controlador de memoria del dispositivo, o se ha quedado sin bloques de repuesto para reasignar los bloques fallados. En ese caso, no se puede confiar en ninguna área del dispositivo.

A través de [ubuntu] Error Check USB Flash Drive , finalmente encontré esto, lo que podría ser útil:

• http://oss.digirati.com.br/f3/ "F3: una alternativa a h2testw"

Llegué a los blogs Fight Flash Fraud y SOSFakeFlash, que recomiendan el software H2testw (ver aquí o aquí) para probar memorias flash. Descargué H2testw y encontré dos problemas con él: (1) es solo para Windows y (2) no es de código abierto. Sin embargo, su autor tuvo la amabilidad de incluir un archivo de texto que explica lo que hace; Esta página trata sobre mi implementación GPLv3 de ese algoritmo.
Mi implementación es simple y confiable, y no sé exactamente cómo F3 se compara con H2testw ya que nunca he ejecutado H2testw. Llamo a mi implementación F3, que es la abreviatura de Fight Flash Fraud o Fight Fake Flash.

Anexo de @pbhj: F3 está en los repositorios de Ubuntu. Tiene dos partes, f3write escribe archivos de 1GB en el dispositivo y f3read intenta leerlos después. De esta forma, se prueba la capacidad y la capacidad de escribir y leer datos de manera efectiva.

Depende del modo de falla, supongo. Son baratos por una razón.

Como dispositivo USB, ver el bus a través del administrador de dispositivos en Windows o la salida de dmesg en Linux le dirá si el dispositivo incluso está reconocido como enchufado. Si no lo está, entonces el controlador a bordo o las conexiones físicas estan rotos.

Si se reconoce que el dispositivo está enchufado, pero no se identifica como un controlador de disco (y no sé cómo podría suceder eso, pero ...), entonces se dispara al controlador.

Si se reconoce como una unidad de disco, pero no puede montarlo, es posible que pueda repararlo a través de fdisk y reescribir la tabla de particiones, luego crear otro sistema de archivos.

Si está buscando el equivalente de SMART , entonces no lo encontrará. Los controladores de memoria USB son baratos. Son almacenamiento de productos básicos, y no están destinados a tener la seguridad y los fallos normales que tienen las unidades modernas.

En el camino hasta hoy, este hilo planteó algunas preguntas.

- ¿Cuánto tiempo llevará esto (implícito en la discusión de dejar que se ejecute durante la noche).

Actualmente estoy probando un USB 3.0 128G Sandisk usando sudo badblocks -w -s -o, está conectado a mi tarjeta PCIe USB 3 / USBC en un Athlon 64x2 anterior. Por lo tanto, USB3 en USB3 en PCIe debería ser bastante rápido.

Aquí está la línea de comandos de mi consola con 33% de finalización:

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

y nuevamente más tarde:

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

Luego vino este segmento:

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

Este proceso se repite con oxaa, luego 0x55, 0xff y finalmente 0x00.

ArchLinux dio una declaración sin reservas:

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

NB: Las pruebas comenzaron alrededor de las 8:30 p.m., las pruebas se completaron antes de las 8:45 a.m. al día siguiente, completando en aproximadamente 12 horas para mi situación .

- Las pruebas destructivas no son el único método posible.

Wikipedia ofreció esta declaración:

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.

Mi página de manual de distribución actual confirma que -n no es destructivo.

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

Y finalmente que no vale la pena. declaración.

Una declaración resumida, basada en la situación de miles de millones de sitios de memoria en un chip flash, una falla es una celda que ya ha sido escrita y borrada decenas de miles de veces, y ahora está fallando. Y cuando una prueba muestra que una celda ha fallado, recuerde que cada archivo que agregó y borró está ejecutando esos ciclos.

La idea aquí es que cuando 1 celda falla, muchas más celdas también están alcanzando el mismo punto de falla. Una celda falló hoy, pero la usas normalmente por un tiempo más, luego fallan 3 celdas más, luego fallan 24 más, luego 183, y antes de que te des cuenta, la matriz de memoria está plagada de puntos defectuosos. Solo hay unas pocas células que pueden morir antes de que su capacidad utilizable comience a disminuir y eventualmente disminuya rápidamente. ¿Cómo sabrá que fallan más células? Entonces, las publicaciones aquí están protegiendo sus datos al decir que una vez que tiene una celda defectuosa, ya ha terminado con respecto al almacenamiento confiable. Su uso aún puede darle algunos meses.

Son tus datos.

HTH

Muchas fallas están completas o permiten que una ubicación admita múltiples ubicaciones. Escribí un pequeño programa de lectura y escritura aleatoria que usa un número primo para un generador de números pseudoaleatorio, tanto para patrones como para direcciones. Las lecturas están escalonadas detrás de las escrituras por suficientes páginas para garantizar que no estoy probando la memoria caché de ram en el sistema. Todavía no está parametrizado, solo configuré un dispositivo 64G en mi sistema con 8G ram. Siéntase libre de criticar, parametrizar, hacerlo más inteligente.

Este es un control poderoso y más rápido que hacer cada byte de abajo hacia arriba, pero también es un excelente generador de intercambio (despliega casi todo lo demás). Puse el intercambio en 1 temporalmente y se hizo más lento pero más tolerable para otras aplicaciones. Cualquier consejo sobre cómo sintonizar contra el intercambio también sería apreciado:

$ 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 ;
        }
}

Las unidades USB son bastante rudimentarias, ¡no hay muchas cosas que puedan salir mal en ellas! En general, si aparece como una unidad y puede formatearlo, entonces funciona. Puede intentar echar un vistazo a la versión portátil de CrystalDiskInfo, ya que es una herramienta de análisis rápida y liviana. Sin embargo, muy pocos dispositivos USB informan sobre información SMART y similares.