मैं लिनक्स में एसडी कार्ड की पूरी क्षमता का परीक्षण कैसे कर सकता हूं?


17

मैंने ईबे से 64 जीबी एसडी कार्ड खरीदा। यह ठीक काम करता है जब मैं एक आर्क लिनक्स एआरएम छवि को जलाता हूं और इसका उपयोग मेरे रास्पबेरी पाई को बूट करने के लिए करता हूं।

हालाँकि, जब मैं कार्ड की सभी क्षमता का उपयोग करने के लिए उस पर एकल ext4 विभाजन बनाने का प्रयास करता हूं, तो त्रुटियां होती हैं। mkfs.ext4हमेशा खुशी से खत्म होता है; हालाँकि, विभाजन को mountसंपादित नहीं किया जा सकता है , हमेशा एक त्रुटि फेंकने और dmesgकर्नेल संदेश शामिल करता है Cannot find journal। यह कम से कम दो प्लेटफार्मों पर मामला साबित हुआ है: आर्क लिनक्स एआरएम और उबंटू 13.04।

दूसरी ओर, मैं त्रुटि के बिना एक FAT32 विभाजन बना और माउंट कर सकता हूं (एक पूर्ण क्षमता की जांच नहीं की गई है)।

मैंने सुना है कि कुछ बुरे लोग एसडी कार्ड इंटरफ़ेस को ओएस की गलत क्षमता की रिपोर्ट करने के लिए बदल सकते हैं (यानी कार्ड वास्तव में केवल 2 जीबी है लेकिन कार्ड को बेहतर कीमत पर बेचने के लिए यह 64 जीबी के रूप में रिपोर्ट करता है)।

मुझे पता है कि badblocksखराब ब्लॉक के लिए एसडी कार्ड की जांच करने के लिए मेरे जैसे उपकरण मौजूद हैं। badblocksइस तरह की समस्याओं का पता लगा सकते हैं ? यदि नहीं, तो कार्ड का परीक्षण करने के लिए मेरे पास और कौन से उपाय मौजूद हैं?

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

अपडेट करें

संचालन और संदेश:

~$ sudo mkfs.ext4 /dev/sde1
mke2fs 1.42.5 (29-Jul-2012)
Filesystem label=
OS type: Linux
Block size=4096 (log=2)
Fragment size=4096 (log=2)
Stride=0 blocks, Stripe width=0 blocks
4096000 inodes, 16383996 blocks
819199 blocks (5.00%) reserved for the super user
First data block=0
Maximum filesystem blocks=4294967296
500 block groups
32768 blocks per group, 32768 fragments per group
8192 inodes per group
Superblock backups stored on blocks: 
    32768, 98304, 163840, 229376, 294912, 819200, 884736, 1605632, 2654208, 
4096000, 7962624, 11239424

Allocating group tables: done                            
Writing inode tables: done                            
Creating journal (32768 blocks): done
Writing superblocks and filesystem accounting information: done   

~$ dmesg | tail
...
[4199.749118]...
~$ sudo mount /dev/sde1 /mnt
mount: wrong fs type, bad option, bad superblock on /dev/sde1,
   missing codepage or helper program, or other error
   In some cases useful info is found in syslog - try
   dmesg | tail  or so

~$ dmesg | tail
...
[ 4199.749118]...
[ 4460.857603] JBD2: no valid journal superblock found
[ 4460.857618] EXT4-fs (sde1): error loading journal

अपडेट करें

मैं चला हूं badblocks /dev/sdeलेकिन यह कोई त्रुटि नहीं रिपोर्ट करता है। इसका मतलब है कि शेष कारण हैं:

  • एसडी कार अच्छी है लेकिन किसी कारण mke2fsसे mountया कर्नेल में एक बग है जो समस्या का कारण बनता है।

  • मुझे इस तरह से धोखा दिया गया badblocksकि हार का पता नहीं चल सकता। यह प्रशंसनीय है क्योंकि मुझे लगता badblocksहै कि सिर्फ कुछ जगह में ही पढ़ा-लिखा टेस्ट कर रहा है। हालाँकि, चीटर आउटबाउंड क्षेत्रों की पहुँच को कुछ इनबाउंड ब्लॉक से जोड़ सकता है। इस मामले में इन-प्लेस राइट-रीड चेक समस्या का पता लगाने में सक्षम नहीं है।

यदि कोई आवेदन नहीं है तो उचित परीक्षण कर सकते हैं, मुझे लगता है कि मैं इसे जांचने के लिए एक सरल सी कार्यक्रम लिखने की कोशिश कर सकता हूं।


क्या आपने इसे SDXC USB कार्ड रीडर में आज़माया है?
इग्नासियो वाज़केज़-अब्राम्स

साथ ही, क्या सिस्टम लॉग में कोई भी संदेश त्रुटियों के रूप में उसी समय दिखाई देते हैं?
इग्नासियो वाज़केज़-अब्राम्स

मैंने देशी रास्पबेरी पाई कार्ड रीडर, और मेरे उबंटू डेस्कटॉप के लिए बाहरी कार्ड रीडर के साथ भी कोशिश की। मैंने कहा है कि dmesgकर्नेल संदेश दिखाता है और मुझे यकीन है कि यह त्रुटियों के रूप में एक ही समय में प्रकट होता है क्योंकि मैंने उनसे पहले और बाद में और उनकी तुलना की थी। मैंने जांच नहीं की है syslogक्योंकि मेरा मानना ​​है dmesgकि संदेश दिखाएंगे।
पृथ्वी इंजन

क्या यह कोई अन्य संदेश दिखाता है?
इग्नासियो वाज़केज़-अब्राम्स

मैंने जो बाहरी कार्ड रीडर का उपयोग किया है वह मेरे अन्य कार्डों के लिए काम कर रहा है, इसमें एसडीएक्ससी कार्ड शामिल हैं। हालांकि उस समस्याग्रस्त व्यक्ति में एक अंतर है: यह एक एसडी एडेप्टर के साथ एक माइक्रो एसडी कार्ड है।
पृथ्वी इंजन

जवाबों:


26

यदि कोई इसे बाद में देखता है: किसी ने एसडी कार्ड और अन्य ऐसे मीडिया की क्षमता का परीक्षण करने के लिए "एफ 3" नामक एक खुला स्रोत उपकरण लिखा था। यह पाया जा सकता है परियोजना hompage पर और Github में


दरअसल यह SDCards का परीक्षण करने के लिए उस विषय का संदर्भ है ...
फिलिप गचौड

6

धोखाधड़ी की पुष्टि अब निम्नलिखित चरणों द्वारा की गई है:

  • एक यादृच्छिक डेटा फ़ाइल उत्पन्न करें। (4194304 = 4 × 1024 × 1024 = 4 MiB, कुल आकार = 40 × 4 MiB = 160 MiB)

    कमान:

    dd if=/dev/urandom of=test.orig bs=4194304 count=40
    40+0 records in
    40+0 records out
    167772160 bytes (168 MB) copied, 11.0518 s, 15.2 MB/s
    
  • एसडी कार्ड में डेटा कॉपी करें। (2038340 × 4096 = 8153600 KiB = 7962.5 MiB)

    कमान:

    sudo dd if=test.orig of=/dev/sde seek=2038399 bs=4096
    40960+0 records in
    40960+0 records out
    167772160 bytes (168 MB) copied, 41.6087 s, 4.0 MB/s
    
  • एसडी कार्ड से डेटा वापस पढ़ें।

    कमान:

    sudo dd if=/dev/sde of=test.result skip=2038399 bs=4096 count=40960
    40960+0 records in
    40960+0 records out
    167772160 bytes (168 MB) copied, 14.5498 s, 11.5 MB/s
    
  • परिणाम दिखाओ

    कमान:

    hexdump test.result | less
    ...
    0000ff0 b006 fe69 0823 a635 084a f30a c2db 3f19
    0001000 0000 0000 0000 0000 0000 0000 0000 0000
    *
    1a81000 a8a5 9f9d 6722 7f45 fbde 514c fecd 5145
    
    ...
    

क्या हुआ? हमने शून्य का अंतर देखा। यह एक संकेतक है कि यादृच्छिक डेटा वास्तव में कार्ड को नहीं लिखा गया है। लेकिन डेटा के बाद वापस क्यों आते हैं 1a81000? जाहिर है कार्ड में एक आंतरिक कैश है।

हम कैश के व्यवहार की जांच करने का भी प्रयास कर सकते हैं।

hexdump test.orig | grep ' 0000 0000 '

कोई परिणाम नहीं प्रदान करता है, जिसका अर्थ है कि उत्पन्न बकवास में ऐसा कोई पैटर्न नहीं है। तथापि,

hexdump test.result | grep ' 0000 0000 '
0001000 0000 0000 0000 0000 0000 0000 0000 0000
213b000 0000 0000 0000 0000 0000 0000 0000 0000
407b000 0000 0000 0000 0000 0000 0000 0000 0000
601b000 0000 0000 0000 0000 0000 0000 0000 0000

4 मैच हैं।

तो यही कारण है कि यह badblocksचेक पास करता है । आगे के परीक्षण दिखा सकते हैं कि वास्तविक क्षमता 7962.5 एमबी है, या 8 जीबी से थोड़ा कम है।

मैं यह निष्कर्ष निकालता हूं कि यह केवल यादृच्छिक हार्डवेयर विफलता होने की संभावना नहीं है, लेकिन एक तरह का धोखा (यानी धोखाधड़ी) होने की संभावना है। मैं जानना चाहता हूं कि मैं अन्य पीड़ितों की मदद के लिए क्या कार्रवाई कर सकता हूं।

अपडेट 11/05/2019

  • लोगों ने मुझसे पूछा कि मुझे कैसे पता लगा कि सही seekपैरामीटर है 2038399। मैंने ऊपर दिखाए गए अनुभव की तुलना में बहुत अधिक अनुभव किया। मूल रूप से आपको पहले स्थान पर अनुमान लगाना होगा। आपको डेटा के उचित आकार का अनुमान लगाना होगा, और आपको यह अनुमान लगाना होगा कि डेटा भ्रष्टाचार कहां था। लेकिन आप हमेशा मदद करने के लिए बिसनेस विधि का उपयोग कर सकते हैं।

  • नीचे दी गई टिप्पणी में मुझे लगा कि मुझे माना गया है कि ऊपर दूसरा चरण (एसडी कार्ड में डेटा कॉपी करें) केवल 1 सेक्टर की नकल करता है। लेकिन मैं अपने एक्सपीरिएंस में यह गलती नहीं कर रहा था। इसके बजाय, यह seekदिखाना था कि "शो परिणाम" चरण में ऑफसेट 1000डेटा के दूसरे क्षेत्र में बस होता है। यदि seek2038399 क्षेत्र हैं, तो भ्रष्टाचार 2038400 वें क्षेत्र में है।


(१) संख्या २०३40३४० और २०३ come३ ९९ कहाँ से आती हैं? (2) क्यों प्रयोग करते हैं  bs=4194304 count=40 जब से पढ़ /dev/urandom लेकिन   bs=4096 count=40960  जब करने के लिए लिखित और एसडी कार्ड से पढ़? (वे गणितीय रूप से समतुल्य हैं; 167772160 बाइट्स प्रत्येक।)
स्कॉट

1) मैंने bieec tecnique का उपयोग Thie ऑफसेट का पता लगाने के लिए किया। के रूप में bisec प्रक्रिया जवाब के लिए बहुत ही क्रियात्मक है, मैं बस उन्हें और अधिक निर्वासन के बिना एक स्पष्ट के रूप में डाल दिया। 2) हाँ गणना समान है; लेकिन मुझे नहीं पता कि मुझे कार्ड के सेक्टर आकार से मेल खाना चाहिए, जो मुझे विश्वास है कि 4096 है।
पृथ्वी इंजन

ओह, बिंदु 2 के लिए) मैं उपयोग करता हूं seek, इसलिए मैंने केवल कार्ड के लिए 1 क्षेत्र लिखा था, जो डेटा हस्तांतरण की मात्रा को बचाता है। कारण, जब मैंने बड़े डेटा ब्लॉक का प्रयोग किया, तो यही कारण है कि उत्पन्न डेटा फ़ाइल 160MiB है।
पृथ्वी इंजन

आपकी दूसरी टिप्पणी का कोई मतलब नहीं है। आपके उत्तर में दूसरा कमांड - वह जो कार्ड पर लिखता है - है sudo dd if=test.orig of=/dev/sde seek=2038399 bs=4096। और जाहिर है कि आप सही हैं; यह उपयोग करता है seek। और, हाँ, तकनीकी रूप से, यह उपयोग नहीं करता है count। … (Cont'd)
स्कॉट

(Cont'd) ... लेकिन आप कहते हैं कि "मैंने केवल कार्ड के लिए 1 सेक्टर लिखा था, जो डेटा ट्रांसफर की मात्रा को बचाता है।" यह स्पष्ट रूप से गलत है; countविनिर्देश के बिना , ddपूरे इनपुट को स्थानांतरित करता है (यानी, यह ईओएफ या एक त्रुटि तक स्थानांतरित होता है)। तो यह कमांड पूरी सामग्री को स्थानांतरित करता है test.orig, जो कि 4096 बाइट्स का 40960 रिकॉर्ड है, कुल 167772160 बाइट्स के लिए (जैसा मैंने कहा)।
स्कॉट

3

सबसे पहले, @Radtoo द्वारा F3 उत्तर पढ़ें । यह सही तरीका है।

मैंने किसी तरह इसे याद किया है, और अपने तरीके से कोशिश की है:

  1. 1gb परीक्षण फ़ाइल बनाएँ: dd if=/dev/urandom bs=1024k count=1024 of=testfile1gb

  2. उस फ़ाइल की प्रतियां sdcard को लिखें (64 GB में sdcard का आकार): for i in $(seq 1 64); do dd if=testfile1gb bs=1024k of=/media/sdb1/test.$i; done

  3. फ़ाइलों की md5 की जाँच करें (सभी अंतिम, अपूर्ण, मेल खाना चाहिए): md5sum testfile1gb /media/sdb1/test.*


यह एक आसान और त्वरित तरीका है।
पृथ्वी इंजन

यह विधि यहाँ अच्छी तरह से प्रलेखित है ccollins.wordpress.com/2016/01/18/testing-sd-cards-with-linux
फिलिप गाचौड

2

एसडी कार्ड की पूरी क्षमता का परीक्षण करने का सबसे सरल तरीका यह है कि इसे फाइलों के साथ भरा जाए, फिर सत्यापित करें कि फाइलें सही हैं: diff -qr /directory/on/computer /directory/on/SD

वैकल्पिक रूप से, आप फ़ाइल में पैटर्न, या हैश की श्रृंखला लिखने के लिए कार्यक्रमों का उपयोग कर सकते हैं, और फिर सत्यापित कर सकते हैं कि वे सही हैं।

जैसा कि @Earthy Engine ने बताया, SD कार्ड को भरना महत्वपूर्ण है, फिर डेटा को पढ़ें, पारंपरिक दृष्टिकोणों के रूप में, जो कि डेटा के एक छोटे से ब्लॉक को लिखते हैं, फिर इसे पढ़ते हैं, नकली SSD कार्ड द्वारा मूर्ख बनाया जाता है।


2

मैंने एक छोटी स्क्रिप्ट लिखी है जो निम्नलिखित काम करती है।

लक्ष्य USB या SC कार्ड के लिए एक अस्थायी निर्देशिका बनाता है

md5sum चेकसम के साथ एक 5MB बेतरतीब ढंग से उत्पन्न संदर्भ फ़ाइल बनाता है

लक्ष्य के लिए संदर्भ फ़ाइल को स्वीकार करता है और पढ़ने / लिखने की सफलता की पुष्टि करने के लिए लक्ष्य से एक md5sum चेक बनाता है

चेकसम क्षमता में त्रुटि होने पर (100%) लक्ष्य को पूरा करता है या रुक जाता है

-स्क्रीप स्वाभाविक रूप से बंद हो जाता है, यह लक्षित रिपोर्ट आकार, प्रयुक्त और नि: शुल्क मात्रा प्रदर्शित करता है।

इस स्क्रिप्ट के साथ मैंने निष्कर्ष निकाला है कि मुझे एक eBay विक्रेता द्वारा फटकारा गया था जिसने 64GB के लिए 8GB माइक्रोएसडी पास किया था

#!/bin/bash
#Save file as 'filltext' and remember to set the executable flag to run it
if [ -d "$1" ]; then
 if [ -d "$1/tmp" ]; then
  echo "."
 else
  mkdir $1/tmp
 fi

#Make a tmp file and fill it with 3MB of junk
 TMPTSTR=$(mktemp)      
 base64 </dev/urandom  | head -c 5000000 > $TMPTSTR

 TESTVAL=$(md5sum $TMPTSTR | awk '{ print $1 }')

 while $CHECKEDOK; do

  FL=$( tr -dc A-Za-z0-9 </dev/urandom  | head -c 5).TEST

  cp $TMPTSTR $1/tmp/$FL
  TESTTMP=$(md5sum $1/tmp/$FL | awk '{ print $1 }')
  if [ "$TESTVAL" != "$TESTTMP" ]; then   
   echo "Checksum ERROR"
   echo "Original: $TESTVAL Temp File:$TESTTMP"
   CHECKEDOK=false
   df $1 -Ph
   echo 
   echo 
   echo "Removing test files"
   rm $1/tmp -r
   rm $TMPTSTR
   df $1 -Ph
  else
   #echo -n "$FL..."
   clear
   df $1 -Ph
  fi
 done

else
 echo "Error: Directory $1 does not exists."
 echo "Usage: filltest [PATH]"
 echo
 echo "Try the PATH of a mounted USB dongle or SD card to confirm it's capacity"

fi

1
यह संभवतः भ्रामक परिणाम देगा। चूंकि OS बफ़र्स फ़ाइल सिस्टम लिखते हैं, आप ज्यादातर अपने सिस्टम की मेमोरी का परीक्षण कर रहे हैं, एसडी कार्ड का नहीं।
सेरीन

"hdparm -W 0 / dev / disk" को क्रियान्वित करने से बफ़र लिखी समस्या को हल करना चाहिए।
माइकल

1

संख्याओं का एक क्रम लिख सकते हैं (प्रत्येक पंक्ति 16 बाइट्स है) और फिर सामग्री को सत्यापित करें:

dd if=<(seq -w 0 123456789012345) of=/dev/yourSdHere

फिर स्किप == आउटपुट सत्यापित करें (स्किप वैल्यू के एक छोटे से नमूने का उपयोग करके जो रिकॉर्ड की संख्या कम है) उदाहरण के लिए स्किप = 9876 :

dd if=/dev/yourSdHere bs=16 count=1 skip=9876
000000000009876
1+0 records in
1+0 records out
16 bytes copied, ...

या, एक लाइनर के साथ 20 स्थानों का एक नमूना बनाएं:

seq -w 000000000000000 NumberOfWrittenRecords | shuf | head -20 | while read i; do [[ $(dd if=/dev/yourSdHere bs=16 count=1 skip=$i) == $i ]] && echo ok || echo bad; done
  • सुनिश्चित करें कि आप एसडी कार्ड को लिख रहे हैं
  • एक फ़ाइल पर लिखें of=tempFileOnSD, यदि आप अपने कार्ड को संग्रहीत डेटा को नष्ट करने से बचना चाहते हैं (प्रासंगिक केवल अगर यह नकली नहीं है)
  • 64 जीबी के रूप में लेबल किए गए 8 जीबी कार्ड के मामले में, सभी 20 परीक्षणों को पास करने का मौका है (8 जीबी / 64 जीबी) ** 20 <1-18

1
इससे पहले कि मैं समझ रहा था कि आप क्या कह रहे थे, मुझे आपका उत्तर तीन बार पढ़ना था: "छोड़ें सत्यापित करें == आउटपुट" स्पष्ट नहीं है। और, जब तक मैं कुछ याद नहीं कर रहा हूँ, आपके दृष्टिकोण के लिए आवश्यक है कि उपयोगकर्ता 123456789012345 कमांड चलाए और  मैन्युअल रूप से आउटपुट का निरीक्षण करे! जाहिर है कि यह अनुचित है। सिर्फ seq -w 0 123456789012345 > /dev/yourSdHereऔर सिर्फ क्यों नहीं seq -w 0 123456789012345 | cmp - /dev/yourSdHere?
स्कॉट

टिप्पणी के लिए धन्यवाद :) मैंने अपना उत्तर संपादित कर लिया है, आशा है कि अब यह बेहतर है!
करपाड़ा

इसके अलावा, 123456789012345 प्रत्येक संख्या को 16 बाइट्स बनाने के लिए 15 अंकों की संख्या है। कोई SD पर 16byte ब्लॉकों की संख्या का उपयोग कर सकता है
karpada
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.