लिनक्स में यूएसबी स्टिक के भौतिक स्वास्थ्य की जांच कैसे करें?

Question

यूएसबी स्टिक की स्वास्थ्य स्थिति की जांच कैसे करें?

मुझे कैसे पता चलेगा कि मरम्मत से परे एक यूएसबी टूट गया है, या मरम्मत योग्य नहीं है?

Comments

इसे दूर फेंक दो। आपका निवेश किया गया समय नया खरीदने की तुलना में अधिक महंगा है।

— मेल्क

मुझे @mailq से सहमत होना होगा। आप इन दिनों $ 2.00 के लिए एक सभ्य 4 जीबी थंब ड्राइव खरीद सकते हैं।

— iglvzx

@iglvzx खैर सवाल बता नहीं है, अगर यह एक सस्ते से एक है, या कुछ + 32Gb तेजी से एक को एनक्रिप्ट ...

— varesa

Answer 1

SMART जैसे मापदंडों के लिए USB मेमोरी स्टिक को क्वेरी करने का कोई तरीका नहीं है; मैं किसी भी मेमोरी स्टिक के बारे में नहीं जानता जो सार्वजनिक रूप से उपलब्ध स्वामित्व सॉफ्टवेयर के माध्यम से भी ऐसा करने का समर्थन करता है। सबसे अच्छा आप यह कर सकते हैं कि आप पूरे उपकरण का उपयोग करके सफलतापूर्वक + लिख सकते हैं badblocks।

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

आप लेखन परीक्षणों में से एक को निर्दिष्ट करना चाहते हैं, जो छड़ी के सभी डेटा को मिटा देगा; पहले एक बैकअप बनाओ।

dmesgयूएसबी स्टिक में प्लग करने के बाद डिवाइस को ढूंढें ; आपको एक उपकरण का नाम (सबसे अधिक संभावना sd_, यानी sdc, sdd, आदि) और निर्माता जानकारी दिखाई देगी। सुनिश्चित करें कि आप उचित डिवाइस का उपयोग कर रहे हैं!

यदि स्टिक को एक मान्य फाइल सिस्टम के साथ स्वरूपित किया जाता है, तो आपको unmountपहले यह करना पड़ सकता है ।

उदाहरण वाक्यविन्यास, एक यूएसबी स्टिक के लिए / dev / sdz के रूप में प्रगणित किया जाता है, प्रगति सूचना का उत्पादन करता है, जिसमें usbstick.log लिखा डेटा-विध्वंसक लेखन परीक्षण और त्रुटि लॉग होता है:

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

आपको बाद में स्टिक को फिर से शुरू करने और सुधार करने की आवश्यकता होगी, यह मानते हुए कि यह गुजरता है; यह परीक्षण छड़ी पर सब कुछ मिटा देगा। कोई भी विफलता डिवाइस की मेमोरी नियंत्रक की विफलता का संकेत देती है, या यह विफल ब्लॉकों को हटाने के लिए स्पेयर ब्लॉकों से बाहर चला गया है। उस स्थिति में, डिवाइस के किसी भी क्षेत्र पर भरोसा नहीं किया जा सकता है।

Comments

बैडब्लॉक शायद सबसे अच्छा विकल्प है। टिप्पणियां जो "इसके लायक नहीं हैं" पूरी तरह से कई मामलों को याद करती हैं जब यह बहुत आवश्यक हो सकता है (उदाहरण के लिए, एक कंपनी ने माल फ्लैशड्राइव खरीदा हो सकता है, और यह देखना चाहेंगे कि वे कितनी बुरी तरह से घोटाला कर गए ...)

— रिचलेव

जैसा कि लिंक किए गए विकिपीडिया लेख में बताया गया है, वहाँ भी है e2fsck -cजो badblocksप्रभावी रूप से फाइल सिस्टम से उन बैडब्लॉक को छुपाता है, इस प्रकार भ्रष्ट लेखन से बचता है। हालांकि यह ध्यान दिया जाना चाहिए कि, यदि डिस्क को नए बैडब्लॉक मिल गए हैं तो यह संभवतः क्षतिग्रस्त हो रही है और नए लोग बाद में गिरफ्तार हो सकते हैं, जिसका अर्थ है कि इसका जीवन छोटा है और आपको इसे बदलने पर विचार करना चाहिए।

— igorsantos07

मैं -v ध्वज को जोड़ने का सुझाव देता हूं और साथ ही टर्मिनल विंडो में त्रुटि भी देखता हूं। (यदि आप इसे उदाहरण के लिए रात भर चलने दें। लॉगफाइल एक त्वरित दृश्य के लिए सहायक नहीं है कि यह कितना बुरा है।

— तिलो

@BeeDee, क्या हमें पूरे डिवाइस या सिर्फ कुछ विभाजन का उपयोग करना चाहिए या इससे कोई फर्क नहीं पड़ता? मेरा मतलब है / देव / sdz या / देव / sdz1?

— श्री पी।

@Pisek आपको पूरे उपकरण का उपयोग करना चाहिए, क्योंकि यह केवल विभाजन नहीं, बल्कि डिवाइस विफल हो रहा है।

— हाय-एंजेल

Answer 2

Via [ubuntu] USB फ्लैश ड्राइव की त्रुटि की जांच करें , मुझे अंततः यह मिल गया, जो सहायक हो सकता है:

• http://oss.digirati.com.br/f3/ "F3 - h2testw का विकल्प"

मैं ब्लॉग पर पहुंच गया फाइट फ्लैश फ्रॉड और SOSFakeFlash, जो फ्लैश यादों का परीक्षण करने के लिए सॉफ्टवेयर H2testw (यहां या यहां देखें) को पुन: प्रस्तुत करता है। मैंने H2testw डाउनलोड किया और इसके साथ दो मुद्दे पाए: (1) यह केवल विंडोज के लिए है, और (2) यह ओपन सोर्स नहीं है। हालाँकि, इसका लेखक एक पाठ फ़ाइल को शामिल करने के लिए पर्याप्त था जो बताता है कि यह क्या करता है; यह पृष्ठ उस एल्गोरिथ्म के मेरे GPLv3 कार्यान्वयन के बारे में है।
मेरा कार्यान्वयन सरल और विश्वसनीय है, और मुझे नहीं पता कि F3 की तुलना H2testw से कैसे की जाती है क्योंकि मैंने कभी भी H2testw नहीं चलाया है। मैं अपने कार्यान्वयन F3 को कॉल करता हूं, जो कि फाइट फ्लैश फ्रॉड या फाइट फेक फ्लैश के लिए कम है।

@Pbhj द्वारा परिशिष्ट: F3 उबंटू रिपो में है। इसके दो भाग हैं, f3write डिवाइस को 1GB फाइलें लिखता है और f3read उन्हें बाद में पढ़ने का प्रयास करता है। इस तरह से क्षमता और लिखने की क्षमता और प्रभावी ढंग से डेटा का परीक्षण किया जाता है।

Comments

क्या F3 ओवर का कोई फायदा है badblocks?

— ज़ाज़

@Zaz जब तक मैं इसे समझता हूं, बैडब्लॉक नकली फ्लैश ड्राइव का पता लगाने के लिए नहीं बनाया गया है और न ही उनके लिए कोई त्रुटि की रिपोर्ट कर सकता है ।

— बेमपिन

Answer 3

यह विफलता मोड पर निर्भर करता है, मुझे लगता है। वे एक कारण के लिए सस्ते हैं।

USB डिवाइस के रूप में, विंडोज में डिवाइस मैनेजर के माध्यम से बस को देखना या लिनक्स में dmesg का आउटपुट आपको बताएगा कि क्या डिवाइस को प्लग किए जाने के रूप में भी पहचाना जाता है। यदि यह नहीं है, तो या तो बोर्ड पर नियंत्रक या भौतिक कनेक्शन। टूटे हैं।

यदि डिवाइस को प्लग-इन के रूप में पहचाना जाता है, लेकिन डिस्क नियंत्रक के रूप में पहचाना नहीं जाता है (और मुझे नहीं पता कि यह कैसे हो सकता है, लेकिन ...) तब नियंत्रक को गोली मार दी जाती है।

यदि इसे डिस्क ड्राइव के रूप में पहचाना जाता है, लेकिन आप इसे माउंट नहीं कर सकते हैं, तो आप इसे fdisk के माध्यम से सुधारने और विभाजन तालिका को फिर से लिखने में सक्षम हो सकते हैं, फिर एक और फाइल सिस्टम बना सकते हैं।

यदि आप SMART के बराबर की तलाश कर रहे हैं , तो आप इसे नहीं पाएंगे। थंबड्राइव कंट्रोलर सस्ते होते हैं। वे कमोडिटी स्टोरेज हैं, और इसका मतलब यह नहीं है कि आधुनिक ड्राइव्स में सामान्य फेलोफेसेस और इंटेलिजेंस हैं।

Answer 4

आज के रास्ते के साथ, इस धागे ने कुछ सवाल उठाए।

- यह कितना समय लगेगा (रात भर चलने देने की चर्चा से निहित)।

मैं वर्तमान में USB 3.0 128G Sandisk का उपयोग कर परीक्षण कर रहा हूं sudo badblocks -w -s -o, यह एक पुराने Athlon 64 जी 2 में मेरे USB 3 / USBC PCIe कार्ड से जुड़ा है। तो, PCIe पर USB3 में USB3 काफी तेज होना चाहिए।

यहाँ 33% पूरा होने पर मेरी कंसोल कमांड लाइन है:

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

और फिर बाद में:

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

अगला यह खंड आया:

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

यह प्रक्रिया ऑक्सा के साथ दोहराती है, फिर 0x55, 0xff, और अंत में 0x00।

ArchLinux ने एक अयोग्य बयान दिया:

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

NB: परीक्षण लगभग 8:30 बजे शुरू किया गया था, परीक्षण अगले दिन सुबह 8:45 से पहले पूरा हो गया था, मेरी स्थिति के लिए लगभग 12 घंटे में पूरा हुआ ।

- विनाशकारी परीक्षण केवल संभव तरीका नहीं है।

विकिपीडिया ने इस बयान की पेशकश की:

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.

मेरा वर्तमान डिस्ट्रो मैन पेज इस बात की पुष्टि करता है कि एन एक nondestructive है।

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

और अंत में कि यह इसके लायक नहीं है। बयान।

एक संक्षिप्त बयान, एक फ्लैश चिप में अरबों मेमोरी साइटों की स्थिति के आधार पर, एक विफलता एक सेल है जो पहले से ही दसियों हजार बार लिखी और मिटा दी गई है, और अब विफल हो रही है। और जब एक परीक्षण दिखाता है कि कोई सेल विफल हो गई है, तो याद रखें कि आपके द्वारा जोड़ी गई प्रत्येक फ़ाइल को जोड़ा और मिटा दिया गया है।

यहां विचार यह है कि जब 1 सेल विफल हो जाता है, तो कई और कोशिकाएं भी उसी विफलता बिंदु पर पहुंच रही हैं। एक सेल आज विफल हो गया, लेकिन आप इसे सामान्य रूप से थोड़ी देर के लिए उपयोग करते हैं, फिर 3 और सेल विफल हो जाते हैं, फिर 24 और असफल हो जाते हैं, फिर 183, और इससे पहले कि आप इसे जानते हैं, स्मृति सरणी खराब स्पॉट के साथ छलनी होती है। केवल इतनी कोशिकाएँ होती हैं जो आपकी प्रयोज्य क्षमता के गिरने से पहले ही मर सकती हैं, अंततः तेज़ी से गिरती हैं। आपको कैसे पता चलेगा कि अधिक कोशिकाएं विफल हो रही हैं? तो, यहाँ पोस्ट कह रही है कि एक बार खराब सेल होने के बाद आप अपने डेटा की रखवाली कर रहे हैं, आप भरोसेमंद स्टोरेज के संबंध में बहुत काम कर रहे हैं। आपका उपयोग अभी भी आपको कुछ महीने दे सकता है।

यह आपका डेटा है।

HTH

Answer 5

कई विफलताएं या तो पूरी होती हैं या एक स्थान को कई स्थानों का समर्थन करने की अनुमति देता है। मैंने थोड़ा यादृच्छिक लिखा पढ़ा कार्यक्रम लिखा था जो एक छद्म यादृच्छिक संख्या जनरेटर के लिए एक प्रमुख संख्या का उपयोग करता है, दोनों पैटर्न और पते के लिए। यह सुनिश्चित करने के लिए लिखा है कि मैं सिस्टम पर रैम कैश का परीक्षण नहीं कर रहा हूं। यह अभी तक मानकीकृत नहीं है, बस 8G रैम के साथ मेरे सिस्टम पर 64G डिवाइस के लिए सेट किया गया है। बेझिझक आलोचना करें, पैरामीटर करें, इसे स्मार्ट बनाएं।

यह एक शक्तिशाली जाँच है और हर बाइट को ऊपर से नीचे करने की तुलना में तेज़ है, लेकिन यह एक महान स्वैप जनरेटर भी है (लगभग सब कुछ बाहर रोल करता है)। मैंने 1 अस्थायी रूप से स्वैपी लगाई और यह अन्य ऐप्स के लिए धीमी लेकिन अधिक सहनीय हो गई। कैसे स्वैप के खिलाफ धुन के लिए कोई सुझाव भी सराहना की जाएगी:

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

Comments

1024 की तरह 2 की शक्ति का उपयोग करने से बेहतर जाँच या मृत उच्च पता बिट्स की अनुमति होगी, हालांकि प्रति हॉप केवल 8 बाइट्स की जाँच करना।

— डेविड पिकेट

हाँ, यह मृत उच्च बिट्स के मामले को याद करेगा। यह भी पढ़ता है और एक ही पास में लिखता है कि याद कर सकते हैं,

— user313114

Answer 6

USB ड्राइव बहुत अल्पविकसित हैं, बहुत कुछ ऐसा नहीं है जो उन पर गलत हो सकता है! आमतौर पर, अगर यह एक ड्राइव के रूप में दिखाई देता है और आप इसे प्रारूपित कर सकते हैं तो यह काम करता है। आप क्रिस्टलडिस्कइन्फो के पोर्टेबल संस्करण को देखने की कोशिश कर सकते हैं क्योंकि यह एक त्वरित हल्का विश्लेषण उपकरण है। बहुत कम USB छड़ें SMART जानकारी और यद्यपि की तरह वापस रिपोर्ट करती हैं।

Comments

संदर्भ के लिए, यहां अंग्रेजी में क्रिस्टल डिस्क इंफो मैनुअल: क्रिस्टलमार्क. info

— मैट सिमन्स