Como verificar a saúde física de um pendrive no Linux?

Como verificar o status de funcionamento de um stick USB?

Como sei que um USB está quebrado além do reparo ou reparável?

Não há como consultar um cartão de memória USB em busca de parâmetros do tipo SMART; Não conheço nenhum cartão de memória compatível com isso, mesmo por meio de software proprietário publicamente disponível. O melhor que você pode fazer é verificar se consegue ler e gravar com sucesso em todo o dispositivo usando badblocks.

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

Você deseja especificar um dos testes de gravação, que limpará todos os dados no stick; faça um backup primeiro.

Encontre o dispositivo observando dmesgdepois de conectar o dispositivo USB; você verá um nome de dispositivo (provavelmente sd_, ou seja, sdc, sdd etc.) e informações do fabricante. Verifique se você está usando o dispositivo adequado!

Se o stick estiver formatado com um sistema de arquivos válido, você pode precisar unmountprimeiro.

Exemplo de sintaxe, para um pendrive enumerado como / dev / sdz, que gera informações de progresso, com um teste de gravação destrutivo de dados e um log de erros gravados em usbstick.log:

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

Você precisará reparticionar e reformatar o stick posteriormente, supondo que ele passe; este teste irá limpar tudo no bastão. Qualquer falha indica uma falha no controlador de memória do dispositivo ou ficou sem blocos sobressalentes para remapear os blocos com falha. Nesse caso, nenhuma área do dispositivo pode ser confiável.

Via [ubuntu] Erro Ao verificar a unidade flash USB , eu finalmente encontrei isso, o que poderia ser útil:

• http://oss.digirati.com.br/f3/ "F3 - uma alternativa ao h2testw"

Cheguei aos blogs Fight Flash Fraud e SOSFakeFlash, que recomendam o software H2testw (veja aqui ou aqui) para testar memórias flash. Fiz o download do H2testw e encontrei dois problemas: (1) é apenas para Windows e (2) não é de código aberto. No entanto, seu autor teve a gentileza de incluir um arquivo de texto que explica o que faz; Esta página é sobre minha implementação GPLv3 desse algoritmo.
Minha implementação é simples e confiável e não sei exatamente como a F3 se compara ao H2testw, pois nunca executei o H2testw. Chamo minha implementação de F3, que é a abreviação de Fight Flash Fraud ou Fight Fake Flash.

Adendo de @pbhj: F3 está nos repositórios do Ubuntu. Ele tem duas partes: o f3write grava arquivos de 1 GB no dispositivo e o f3read tenta lê-los posteriormente. Dessa forma, a capacidade e a capacidade de gravar e ler efetivamente dados são testadas.

Depende do modo de falha, suponho. Eles são baratos por um motivo.

Como um dispositivo USB, assistir o barramento via gerenciador de dispositivos no Windows ou a saída do dmesg no Linux informará se o dispositivo é reconhecido como estando conectado. Se não estiver, o controlador a bordo ou as conexões físicas estão quebrados.

Se o dispositivo for reconhecido como conectado, mas não for identificado como um controlador de disco (e eu não sei como isso poderia acontecer, mas ...), o controlador será atingido.

Se ele for reconhecido como uma unidade de disco, mas você não conseguir montá-lo, poderá consertá-lo via fdisk e reescrever a tabela de partição e criar outro sistema de arquivos.

Se você procura o equivalente ao SMART , não o encontrará. Controladores Thumbdrive são baratos. Eles são armazenamento de mercadorias e não pretendem ter os falhas normais e a inteligência que os discos modernos possuem.

No caminho para hoje, esse tópico levantou algumas questões.

- Quanto tempo isso levará (implicado na discussão de deixá-lo funcionar da noite para o dia).

Atualmente, estou testando um Sandisk USB 3.0 128G usando sudo badblocks -w -s -o, ele está conectado à minha placa USB 3 / USBC PCIe em um Athlon 64x2 mais antigo. Portanto, o USB3 no USB3 no PCIe deve ser bastante rápido.

Aqui está a linha de comando do meu console com 33% de conclusão:

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

e novamente mais tarde:

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

Em seguida, veio este segmento:

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

Esse processo se repete com oxaa, 0x55, 0xff e, finalmente, 0x00.

O ArchLinux fez uma declaração não qualificada:

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

NB: O teste foi iniciado por volta das 20h30, o teste havia terminado antes das 8h45 do dia seguinte, completando em cerca de 12 horas para a minha situação .

- Testes destrutivos não são o único método possível.

A Wikipedia ofereceu esta declaração:

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.

Minha página de manual de distribuição atual confirma que -n é não destrutivo.

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

E, finalmente, que não vale a pena. declaração.

Uma declaração resumida, com base na situação de bilhões de sites de memória em um chip flash, uma falha é uma célula que já foi gravada e apagada dezenas de milhares de vezes e agora está falhando. E quando um teste mostra que uma célula falhou, lembre-se de que cada arquivo que você adicionou e apagou está executando esses ciclos.

A idéia aqui é que, quando uma célula falha, muitas outras células também atingem o mesmo ponto de falha. Uma célula falhou hoje, mas você a usa normalmente por mais algum tempo, mais 3 células falham, mais 24 falham e depois 183 e, antes que você perceba, a matriz de memória está cheia de pontos ruins. Existem tantas células que podem morrer antes que sua capacidade utilizável comece a cair, eventualmente caindo rapidamente. Como você saberá que mais células estão falhando? Portanto, as postagens aqui estão protegendo seus dados dizendo que, quando você tem uma célula defeituosa, você está praticamente pronto para o armazenamento confiável. Seu uso ainda pode levar alguns meses.

São seus dados.

HTH

Muitas falhas estão completas ou permitem que um local suporte vários locais. Eu escrevi um pequeno programa de leitura e gravação aleatória que usa um número primo para um gerador de números pseudo-aleatórios, para padrões e endereços. As leituras são escalonadas por trás das gravações por páginas suficientes para garantir que eu não estou testando o cache de ram no sistema. Ainda não está parametrizado, basta configurar um dispositivo de 64G no meu sistema com 8G de RAM. Sinta-se livre para criticar, parametrizar, torná-lo mais inteligente.

Essa é uma verificação poderosa e mais rápida do que executar todos os bytes de baixo para cima, mas também é um ótimo gerador de swap (lança quase todo o resto). Coloquei a permutação em 1 temporariamente e ficou mais lenta, mas mais tolerável para outros aplicativos. Quaisquer dicas sobre como ajustar a troca também serão apreciadas:

$ sudo ksh -c 'eco 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 ;
        }
}

Os drives USB são bastante rudimentares, não há muito que possa dar errado neles! Geralmente, se aparecer como uma unidade e você puder formatá-la, funcionará. Você pode tentar dar uma olhada na versão Portable do CrystalDiskInfo, pois é uma ferramenta de análise rápida e leve. No entanto, muito poucos pen drives relatam informações SMART e similares.