ड्राइव अपने आप को दिखाने के तीन तरीके
एक ड्राइव के दो ब्लॉक साइज़ होते हैं, और उनके बीच का फ़र्क ही पूरी कहानी है।
फ़िज़िकल सेक्टर वह है जिसमें मीडियम असल में काम करता है: सबसे छोटी इकाई जिसे ड्राइव बिना अतिरिक्त काम किए पढ़ या लिख सकती है। लॉजिकल ब्लॉक वह है जो ड्राइव होस्ट को बताती है कि वह इसमें काम करती है: वह इकाई जिससे होस्ट उसे एड्रेस करता है।
बाज़ार में तीन जोड़ियाँ मिलती हैं।
512n: नेटिव 512। दोनों साइज़ 512 बाइट। यह पुरानी दुनिया है: 2010 से पहले की हार्ड ड्राइव, और आज किसी काम के साइज़ में नया ख़रीदने लायक कुछ नहीं।
512e: 512-बाइट इम्युलेशन। फ़िज़िकल सेक्टर 4096 बाइट का है, पर ड्राइव 512-बाइट लॉजिकल ब्लॉक बताती है और फ़र्मवेयर में ट्रांसलेट करती है। यह एक ही वजह से है: उन ऑपरेटिंग सिस्टम, बूटलोडर और एप्लिकेशन के साथ कम्पैटिबिलिटी जिन्होंने मान लिया था कि 512 हमेशा रहेगा। इंजीनियरिंग के तौर पर समझदारी, और आगे आने वाली लगभग हर परेशानी की जड़।
4Kn: नेटिव 4K। दोनों साइज़ 4096 बाइट। ड्राइव सच बोलती है, होस्ट उसे उसी इकाई में एड्रेस करता है जो मीडियम इस्तेमाल करता है, और बीच में कोई ट्रांसलेशन लेयर नहीं बैठती।
हर अनअलाइन्ड write पर 512e क्या करता है
तीनों मामलों में read सस्ता है। ड्राइव 4K सेक्टर पढ़ती है और आपने जो 512-बाइट टुकड़ा माँगा वह लौटा देती है।
Write वह जगह है जहाँ यह कहानी महँगी पड़ती है।
अगर होस्ट एक अकेला 512-बाइट लॉजिकल ब्लॉक लिखता है, तो ड्राइव 512 बाइट नहीं लिख सकती। मीडियम में ऐसी कोई इकाई है ही नहीं। इसलिए वह यह करती है:
- पूरा 4096-बाइट फ़िज़िकल सेक्टर पढ़ो।
- उसमें नए डेटा के 512 बाइट मिलाओ।
- पूरा 4096-बाइट सेक्टर वापस लिखो।
यह एक read-modify-write है, और यह एक छोटी write को एक read और एक write में बदल देता है। घूमती डिस्क पर इसका मतलब है प्लैटर के फिर से घूमकर आने का इंतज़ार। 7,200rpm पर एक पूरा चक्कर लगभग 8ms है, जिसका आपने हिसाब नहीं रखा था। फ़्लैश पर कीमत अलग किस्म की है, और write खत्म होने पर भी वह नहीं जाती। उसका अपना सेक्शन नीचे है।
मिसअलाइनमेंट इसका वह रूप है जो सबसे ज़्यादा चोट करता है। अगर कोई पार्टीशन किसी विषम 512-बाइट ऑफ़सेट पर शुरू होता है, जिसका क्लासिक उदाहरण पुराना 63-सेक्टर का चलन है, तो हर 4K फ़ाइलसिस्टम write दो फ़िज़िकल सेक्टरों में फैल जाती है। यह एक read-modify-write नहीं, दो है, हर एक write पर, हमेशा, जब तक कोई ड्राइव को फिर से पार्टीशन न करे।
फ़्लैश पर write amplification
हार्ड ड्राइव पर read-modify-write आपको एक चक्कर का पड़ता है और फिर खत्म। फ़्लैश पर यह ड्राइव की उम्र का पड़ता है, और यह एक ऐसा बिल है जो एक बार भरते हैं और भरते रहते हैं।
Write amplification वह अनुपात है जो असल में NAND पर लिखा गया, उसके मुकाबले जो होस्ट ने लिखने को कहा। 1.0 का अनुपात मतलब ड्राइव ने ठीक उतना लिखा जितना उसे दिया गया। यह कभी 1.0 नहीं होता, क्योंकि फ़्लैश अपनी जगह पर ओवरराइट नहीं कर सकता: ड्राइव एक नया पेज प्रोग्राम करती है, पुराने को stale मार्क करती है, और garbage collection बाद में बचे हुए पेजों को खिसकाता है ताकि पूरा ब्लॉक मिटाया जा सके। वह खिसकाना भी write है।
512e इसके ऊपर एक टाली जा सकने वाली परत जोड़ता है, और वजह एक ऐसा ब्योरा है जिसे साफ़ कहना ज़रूरी है: ड्राइव की ट्रांसलेशन लेयर लगभग 4 KB की इकाइयों में मैप करती है, चाहे वह कोई भी लॉजिकल ब्लॉक साइज़ बताए। 512-बाइट ब्लॉक बताने वाली ड्राइव भी अंदर 4 KB इकाइयाँ ही ट्रैक कर रही है।
तो होस्ट की एक 512-बाइट write ड्राइव के अंदर बन जाती है: 4 KB मैपिंग इकाई पढ़ो, उसमें 512 बाइट मिलाओ, एक नई 4 KB इकाई प्रोग्राम करो। 512 बाइट बदलने के लिए 4096 बाइट NAND तक पहुँचते हैं। उस write के लिए आठ गुना write।
मिसअलाइनमेंट हर write पर कम नाटकीय है और कुल मिलाकर ज़्यादा बुरा। दो मैपिंग इकाइयों में फैली एक 4 KB write दोनों को गंदा करती है, इसलिए 4 KB डेटा के लिए 8 KB प्रोग्राम होता है। यह हर एक write पर 2× amplification है, स्थायी रूप से, जब तक पार्टीशन टेबल ठीक न हो।
इसके आगे के असर ही इसे सिर्फ़ बेतरतीबी से ज़्यादा अहम बनाते हैं:
- ज़्यादा NAND writes का मतलब है garbage collection ज़्यादा बार चलता है, और उसका खिसकाना ख़ुद amplification है।
- SLC write cache जल्दी भरता है, इसलिए ड्राइव पहले ही अपनी धीमी स्थिर अवस्था में आ जाती है और लगातार write throughput गिरता है।
- Program/erase cycles उस अनुपात में खर्च होते हैं जो NAND तक पहुँचा, न कि जो होस्ट ने भेजा। Amplification दुगना कीजिए और उसी वर्कलोड पर ड्राइव की उम्र आधी।
- Endurance रेटिंग, TBW और DWPD, होस्ट writes के हिसाब से बताई जाती हैं। Amplification चुपचाप वह मार्जिन खा जाता है, और ड्राइव उस वारंटी के हिसाब से पहले घिस जाती है जो आपने ख़रीदते वक़्त लगाया था।
Direct और synchronous writes सबसे बुरी स्थिति हैं
ज़्यादातर वक़्त page cache यह सब छुपा लेता है। कर्नेल छोटी writes इकट्ठा करता है, उन्हें मिलाता है, और ड्राइव को 4 KB या उससे बड़ा IO भेजता है, इसलिए read-modify-write कभी होता ही नहीं।
दो फ़्लैग यह सुरक्षा हटा देते हैं, और जिन एप्लिकेशन को durability की परवाह है वे दोनों सेट करते हैं।
O_DIRECT page cache को बायपास करता है।
अब एप्लिकेशन और ड्राइव के बीच ऐसा कुछ नहीं जो 512-बाइट write को सेक्टर के साइज़ की चीज़ में मिला सके।
O_SYNC या O_DSYNC माँगता है कि कॉल लौटने से पहले write स्थायी मीडिया पर हो।
इससे ड्राइव write को किसी volatile बफ़र में रखकर बाद में पड़ोसियों के साथ मिला नहीं पाती।
दोनों को साथ रखिए और हर 512-बाइट write एक पूरा read-modify-write चक्र है जिसे अभी खत्म होना है, अकेले, बिना किसी चीज़ के जिस पर उसे बाँटा जा सके। यहीं 512e ड्राइव पर amplification अपने सैद्धांतिक 8× के क़रीब पहुँचता है, और यह ठीक वही पैटर्न है जो डेटाबेस commit log, ZFS ZIL या Ceph BlueStore WAL बनाते हैं।
Enterprise हार्डवेयर पर इसे power-loss protection बचाता है। PLP वाली ड्राइव synchronous write को तब स्वीकार कर सकती है जब वह कैपेसिटर-समर्थित DRAM बफ़र में हो, जो टिकाऊ है, और फिर भी NAND प्रोग्राम करने से पहले अंदर मिला सकती है। बिना PLP वाली consumer ड्राइव को जवाब देने से पहले फ़्लैश तक पहुँचना पड़ता है, इसलिए वह हर write पर पूरी कीमत देती है। इस तरह के वर्कलोड के लिए PLP वैकल्पिक क्यों नहीं, इसकी एक और वजह।
Proxmox में cache mode तय करता है कि आपको इनमें से क्या मिलेगा:
cache=noneका मतलबO_DIRECTहै: PVE का डिफ़ॉल्ट, और all-flash HA के लिए सही चुनाव। होस्ट page cache रास्ते से बाहर है, इसलिए guest के write पैटर्न ड्राइव तक वैसे ही पहुँचते हैं जैसे guest ने भेजे।cache=directsyncका मतलबO_DIRECTऔरO_DSYNCहै: हर write synchronous। यह समर्पित डेटाबेस-log ड्राइव के लिए एक ख़ास सेटिंग है और आम वर्कलोड के लिए बेकार।
512e बैकिंग डिवाइस पर, 512-बाइट रिकॉर्ड में commit करने वाले guest के साथ cache=directsync लगभग सबसे कम कुशल व्यवस्था है: न होस्ट पर मिलाना, न ड्राइव पर मिलाना, और हर commit पर एक read-modify-write।
और यह वह हिस्सा है जो 4Kn को सिर्फ़ बेहतर नहीं बल्कि ढाँचागत बनाता है।
O_DIRECT माँगता है कि ऑफ़सेट, लंबाई और बफ़र ड्राइव के लॉजिकल ब्लॉक साइज़ पर अलाइन्ड हों।
512e ड्राइव पर यह 512 बाइट है, इसलिए 512-बाइट direct write जायज़ है और ड्राइव चुपचाप उसकी कीमत देती है।
4Kn पर लॉजिकल ब्लॉक 4096 है, इसलिए कर्नेल जो सबसे छोटी direct write स्वीकार करेगा वह 4 KB है।
बीमार पैटर्न ऐसी चीज़ नहीं रहता जिससे आपको बचना है, बल्कि ऐसी चीज़ बन जाता है जिसे स्टैक व्यक्त ही नहीं कर सकता।
मीडियम पर ओवरहेड
दूसरी कीमत ढाँचागत है, और Advanced Format के होने की वजह यही है।
सेक्टर सिर्फ़ उसका डेटा नहीं है। हार्ड ड्राइव पर हर एक के साथ एक sync mark होता है ताकि हेड को पता चले कि सेक्टर कहाँ शुरू होता है, एक gap ताकि लगातार सेक्टर एक-दूसरे में न घुसें, एक address marker, और read errors सुधारने के लिए एक ECC फ़ील्ड।
512-बाइट सेक्टर के साथ आप 4K डेटा के लिए यह सब आठ बार देते हैं। एक 4K सेक्टर के साथ एक बार।
इसके दो नतीजे हैं, और दूसरा पहले से ज़्यादा अहम है:
- प्लैटर का कुछ हिस्सा जो ओवरहेड था, इस्तेमाल लायक क्षमता बन जाता है। Advanced Format बदलाव के दौरान इंडस्ट्री की बताई गई वजह यही थी, कुछ प्रतिशत के निचले दायरे में।
- उसी कुल ओवरहेड में ECC फ़ील्ड बहुत बड़ा हो सकता है। 4096 बाइट बचाने वाला एक मज़बूत कोड 512-512 बाइट बचाने वाले आठ कमज़ोर कोडों से कहीं ज़्यादा सुधारता है। जैसे-जैसे areal density बढ़ी, यह अच्छी बात भर नहीं रही बल्कि error rate को स्वीकार्य रखने का अकेला तरीका बन गई।
फ़्लैश में sync marks या घूमने वाले gaps नहीं होते, पर वही तर्क एक स्तर ऊपर लागू होता है: NAND पेजों में प्रोग्राम होता है, पेज 512 बाइट से कहीं बड़े होते हैं, और ड्राइव की मैपिंग टेबल में हर एड्रेस होने वाली इकाई की एक एंट्री होती है। छोटे लॉजिकल ब्लॉक का मतलब है उतनी ही क्षमता ट्रैक करने के लिए ज़्यादा मेटाडेटा।
होस्ट में ओवरहेड: कमांड और इंटरप्ट
तीसरी कीमत वह है जो लोग चूक जाते हैं, क्योंकि वह ड्राइव पर है ही नहीं।
लॉजिकल ब्लॉक साइज़ तय करता है कि एक IO कम से कम कितना छोटा हो सकता है, यानी उसका फ़र्श। 512-बाइट लॉजिकल ड्राइव पर, फ़ाइलसिस्टम या एप्लिकेशन 512-बाइट write भेजने के लिए आज़ाद है, और हर एक पूरा IO है: एक कमांड बनाया और भेजा गया, एक doorbell write, एक completion queue entry, और खत्म होने की ख़बर देने वाला एक interrupt।
इनमें से हर एक की एक तय कीमत है जिसे इस बात से फ़र्क नहीं पड़ता कि कितना डेटा था। 4KB को आठ 512-बाइट कमांड के रूप में भेजिए और आप वह कीमत आठ बार देते हैं। एक 4K कमांड के रूप में भेजिए और एक बार।
दो ईमानदार शर्तें, क्योंकि यहीं यह तर्क आमतौर पर बढ़ा-चढ़ाकर कहा जाता है।
बड़े IO के लिए लॉजिकल ब्लॉक साइज़ कमांड की गिनती में कुछ नहीं बदलता। एक कमांड कई ब्लॉक बता सकता है, इसलिए 1MB की sequential write एक कमांड है, ब्लॉक 512 बाइट के हों या 4K के। बचत सिर्फ़ वहीं असली है जहाँ छोटा IO भेजा जा रहा है।
पर जहाँ छोटा IO भेजा जा रहा है, वहाँ असर बारीक नहीं है: उन आठ requests में से हर एक को कर्नेल को बनाना, शेड्यूल करना और पूरा करना है, हर एक का अपना MSI-X interrupt और user-से-kernel transition है, और ऊँची queue depth पर interrupt storm ऐसे ही आता है। VM के अंदर यह और बुरा है, क्योंकि इनमें से हर interrupt एक guest context switch भी है।
और आधुनिक NVMe कंट्रोलर interrupts को मिला देते हैं, इसलिए interrupt की गिनती बस कमांड की गिनती नहीं है। फिर भी हर कमांड का submission और completion काम रहता है, और कुछ लाख IOPS पर हर कमांड की CPU कीमत एक कोर का मापने लायक हिस्सा है। यह वही गणित है जो पासथ्रू सीरीज़ में posted interrupts का है: छोटी तय कीमतें, एक बहुत बड़ी संख्या से गुणा।
4Kn, सेक्टर मेटाडेटा और हार्डवेयर RAID
4096 + 0 फ़ॉर्मैट पर जाने का एक नतीजा है जो लोगों को चौंकाता है, और वह सीधे हार्डवेयर RAID पर पड़ता है।
कुछ RAID कंट्रोलर और स्टोरेज ऐरे सादे 512 या 4096-बाइट सेक्टर इस्तेमाल ही नहीं करते। वे ड्राइव को एक बढ़े हुए साइज़ में फ़ॉर्मैट करते हैं, 520 या 528 बाइट, या 4K के बराबर 4104, 4160 और 4224, क्योंकि हर सेक्टर के वे अतिरिक्त बाइट वह जगह हैं जहाँ कंट्रोलर अपना मेटाडेटा रखता है। यह T10-PI/DIF protection information है, या vendor integrity data, उसी डेटा के साथ रखा गया जिसका वह वर्णन करता है।
4096 + 0 फ़ॉर्मैट के पास उसे रखने की कोई जगह नहीं। सेक्टर शुरू से आख़िर तक डेटा है, और उसे चुनने का पूरा मतलब यही है।
तो जो कंट्रोलर इनलाइन मेटाडेटा चाहता है उसके पास तीन रास्ते हैं, और इनमें से कोई मुफ़्त नहीं:
- ड्राइव को मना कर दे।
- उसे वापस बढ़े हुए फ़ॉर्मैट में फ़ॉर्मैट करे, और आपने अभी जो 4Kn काम किया उसे उलट दे।
- अपना मेटाडेटा ड्राइव पर कहीं और रखे।
तीसरा वह है जहाँ फ़्लैश आपको सज़ा देता है। जिस डेटा का वह वर्णन करता है उससे अलग लिखा गया मेटाडेटा एक दूसरी write है, किसी और ऑफ़सेट पर, किसी और मैपिंग इकाई में। हर उस पेज के लिए जो आप सच में लिखना चाहते थे, एक और NAND पेज प्रोग्राम हुआ। यह ऊपर वाले सेक्शन का amplification है, जानबूझकर वापस लाया गया, ऐसा integrity मेटाडेटा ढोने के लिए जिसे ड्राइव बिना कुछ लिए इनलाइन रख सकती थी अगर आप उसे बढ़े हुए फ़ॉर्मैट में छोड़ देते।
दोनों नहीं मिल सकते। या तो सेक्टर कंट्रोलर का मेटाडेटा ढोता है, या सिर्फ़ आपका डेटा।
इसीलिए फ़्लैश ने हार्डवेयर RAID का तर्क काफ़ी कमज़ोर कर दिया है
इसका बाकी हिस्सा mechanism नहीं बल्कि राय है, इसलिए इसे वैसे ही लीजिए।
हार्डवेयर RAID कंट्रोलर एक समर्पित प्रोसेसर पर चलने वाला फ़र्मवेयर RAID है। “हार्डवेयर” एक CPU, कुछ DRAM और एक बैटरी है। parity निकालने का कोई बुनियादी तौर पर अलग तरीका नहीं। इतिहास में यह आपको एक बैटरी-समर्थित write cache और parity offload देता था, और फ़्लैश पर दोनों तर्क बुरी तरह कमज़ोर पड़े हैं। Enterprise NVMe के पास पहले से अपना power-loss-protected cache है, और कंट्रोलर उन डिवाइसों के आगे एक bandwidth की छत बन जाता है जिनमें से हर एक कई गीगाबाइट प्रति सेकंड भर सकता है।
यह आपसे वे चीज़ें भी छीनता है जो अब आप सच में चाहते हैं:
- डिवाइस की स्थिति गायब हो जाती है। SMART ब्योरा, घिसाव के संकेत और vendor logs जिनसे आप write amplification निकाल सकते हैं, सब एक अपारदर्शी परत के पीछे हैं।
- कोई end-to-end checksum नहीं। कंट्रोलर parity जाँचता है, जो एक गायब ड्राइव पकड़ती है, मौजूद ड्राइव का गलत जवाब नहीं। ZFS और Ceph ख़ुद डेटा का checksum करते हैं और बता सकते हैं कि कौन सी कॉपी गलत है, वह silent corruption जिसे कंट्रोलर सीधे आगे भेज देता है। इसलिए कंट्रोलर गलत समस्या हल कर रहा है।
- ड्राइव पर vendor मेटाडेटा ऐरे को एक कंट्रोलर परिवार से बाँधता है, और जब ख़राब कंट्रोलर ही हो तो यह अपने आप में एक अलग तरह की अविश्वसनीयता है।
- Parity RAID अपना ख़ुद का read-modify-write करता है आंशिक-stripe writes पर, जो ऊपर के सेक्शनों की हर चीज़ के ऊपर जुड़ता है।
Ceph के लिए यह पसंद का मामला भी नहीं है। Proxmox की अपनी hyper-converged सलाह है कि डिस्क HBA या pass-through मोड में दिखनी चाहिए, RAID कंट्रोलर के पीछे नहीं, और ZFS ठीक यही चीज़ उन्हीं वजहों से चाहता है।
तो इस सबसे जो व्यवस्था निकलती है वह है: RAID कंट्रोलर के बजाय एक HBA, ड्राइव शून्य मेटाडेटा के साथ 4Kn फ़ॉर्मैट, और redundancy और checksum ZFS या Ceph करें, जो सच में बता सकते हैं कि कब कोई ड्राइव झूठ बोली। अगर आपके सिस्टम में किसी चीज़ को सच में बढ़ा हुआ सेक्टर फ़ॉर्मैट चाहिए, तो यह एक जानबूझकर किया जाने वाला या-तो/या फ़ैसला है जिसे ड्राइव खाली रहते तय करना है। OSD बन जाने के बाद पता चलने वाली चीज़ नहीं।
512e असल में कहाँ काटता है
यह कहना बेईमानी होगी कि 512e एक आधुनिक सिस्टम को बर्बाद कर देता है, क्योंकि आमतौर पर ऐसा नहीं होता।
एक मौजूदा Linux स्टैक फ़िज़िकल सेक्टर साइज़ पढ़ता है, पार्टीशन उसी पर अलाइन करता है, parted और sfdisk दोनों अब डिफ़ॉल्ट से यह करते हैं, और 4K फ़ाइलसिस्टम ब्लॉक इस्तेमाल करता है।
उस कॉन्फ़िगरेशन में होस्ट 4K-अलाइन्ड 4K IO भेजता है, ड्राइव को कभी read-modify-write की ज़रूरत नहीं पड़ती, और 512e की कीमत लगभग कुछ नहीं।
समस्याएँ ख़ास हैं:
- मिसअलाइन्ड पार्टीशन, आमतौर पर किसी पुराने इंस्टॉल या क्लोन की गई इमेज से विरासत में। हर write पर दो read-modify-write।
- 512e ड्राइव पर
ashift=9के साथ ZFS, क्योंकि ZFS ने बताए गए 512 पर भरोसा किया। हर record write एक read-modify-write बन जाती है, और आप बाद मेंashiftनहीं बदल सकते: pool फिर से बनाना पड़ता है। - 512-बाइट रिकॉर्ड लिखने वाले एप्लिकेशन O_DIRECT के साथ, page cache के मिलाने को बायपास करते हुए। कुछ डेटाबेस और बहुत सारा ख़ास बनाया सॉफ़्टवेयर यह करता है।
- हर वह चीज़ जो लॉजिकल साइज़ को असली मानती है। इम्युलेशन का असली नुकसान यही है: वह एक गलत संख्या बाँटता है, और आगे की चीज़ें उससे फ़ैसले लेती हैं।
4Kn पूरी श्रेणी हटा देता है। ड्राइव उस सेक्टर साइज़ के बारे में झूठ नहीं बोल सकती जो उसके पास है ही नहीं।
फिर भी इनाम के आकार के बारे में साफ़ रहना ठीक है। Seagate की अपनी सलाह है कि 4Kn का पीछा तब साफ़ तौर पर फ़ायदेमंद है जब स्टैक पूरी तरह 4K के लिए ऑप्टिमाइज़ हो और आप हर IOPS गिन रहे हों, जैसे एक ट्यून की गई all-flash tier। उससे नीचे, सही अलाइन्ड आधुनिक Linux पर, अलाइन्ड IO के लिए परफ़ॉर्मेंस का फ़र्क अक्सर छोटा होता है। दूसरा तर्क फ़्लीट की एकरूपता है: पूरी तरह 4Kn सिस्टम में मिले-जुले फ़ॉर्मैट की कोई चौंकाने वाली बात नहीं, और किसी को याद नहीं रखना पड़ता कि कौन सी ड्राइव झूठ बोलती है।
ज़्यादातर ड्राइव बदली जा सकती हैं, अगर vendor इजाज़त दे
यह वह हिस्सा है जो छूट जाता है: 512e अक्सर एक फ़ॉर्मैट सेटिंग है, हार्डवेयर की ख़ासियत नहीं। बहुत सारी enterprise SAS और SATA ड्राइव, और ज़्यादातर enterprise NVMe, 512 बाइट बताते हुए आती हैं और ख़ुशी से 4Kn में फिर से फ़ॉर्मैट हो जाती हैं।
नीचे का सब कुछ डिवाइस का हर बाइट मिटा देता है। अपनी जगह पर बदलने का कोई तरीका नहीं है।
NVMe: nvme-cli
पहले देखिए कि namespace क्या सपोर्ट करता है:
# Lists each LBA format and marks which one is in use
nvme id-ns -H /dev/nvme0n1 | grep -i "lbaf\|data size"
आपको ऐसा फ़ॉर्मैट चाहिए जिसमें Data Size 4096 और Metadata Size 0 हो, best मार्क हो और अभी इस्तेमाल में न हो। फिर उसे लगाइए:
# -l/--lbaf selects the LBA format index from the list above
nvme format /dev/nvme0n1 --lbaf=1 --force
मेटाडेटा साइज़ उतना ही अहम है जितना डेटा साइज़। कुछ फ़ैक्टरी फ़ॉर्मैट हर सेक्टर में अतिरिक्त बाइट रखते हैं, 520, या 4160, ताकि end-to-end T10-PI/DIF protection मेटाडेटा ढो सकें। अगर आपके स्टैक में कुछ भी उसे इस्तेमाल नहीं करता, तो वह हर सेक्टर पर भराव है, इसलिए शून्य-मेटाडेटा वाला फ़ॉर्मैट चुनिए और उससे छुटकारा पाइए। गलती से मेटाडेटा वाला फ़ॉर्मैट चुनने से आपको ऐसी ड्राइव भी मिलती है जो उससे अलग बर्ताव करती है जो आप बनाना चाहते थे, और सेक्टर-साइज़ बदलाव को PI बदलाव के साथ मिलाने से तेज़ के बजाय धीमा पूरा format करना पड़ सकता है।
पूरे होस्ट की ड्राइव के लिए, इसे लूप में चलाइए। इसे extended globs के लिए shopt -s extglob चाहिए, और यह सिर्फ़ वे फ़ॉर्मैट चुनता है जो 4096/0 हैं और इस्तेमाल में नहीं:
shopt -s extglob
for dev in /dev/nvme+([0-9])n+([0-9]); do
# Skip anything that is not actually there
[ -e "$dev" ] || continue
# An LBA format with 4096-byte data, 0-byte metadata, marked Best, not in use
lbaf=$(nvme id-ns -H "$dev" \
| grep -P '(?=.*Metadata Size: 0)(?=.*Data Size: 4096)(?=.*Best)(?!.*in use)' \
| awk '{found=$3} END {print (found != "" ? found : -1)}')
if [ "$lbaf" != "-1" ]; then
echo "Formatting $dev using LBA Format: $lbaf"
nvme format --force --lbaf="$lbaf" "$dev"
else
echo "Skipping $dev: no matching LBA format found."
fi
done
इसमें दो चीज़ें जितना दिखती हैं उससे ज़्यादा काम कर रही हैं।
Glob namespaces से मेल खाता है, nvme0n1, nvme12n3, और जानबूझकर nvme0n1p1 जैसे पार्टीशन से मेल नहीं खाता, क्योंकि पैटर्न n के बाद के अंकों पर खत्म हो जाता है। एक namespace को फिर से फ़ॉर्मैट करने और चलते सिस्टम के साथ कुछ ऐसा करने में जिसे वापस न लाया जा सके, यही फ़र्क है।
और चुनाव सिर्फ़ उसी ड्राइव को बदलता है जो सच में वह देती है जो आपने माँगा। बाकी सब -1 पर गिरता है और छोड़ दिया जाता है, जिसमें तीन अलग मामले आते हैं:
- ड्राइव सिर्फ़ 512 देती है। कोई 4096-बाइट फ़ॉर्मैट नहीं है, इसलिए बदलने को कुछ नहीं और लूप उसे छोड़ देता है। वह कोशिश नहीं करता, और बीच में फ़ेल नहीं होता।
- ड्राइव पहले से 4Kn है। 4096/0 फ़ॉर्मैट ही इस्तेमाल में है, और
(?!.*in use)उसे बाहर करता है, इसलिए उसी होस्ट पर दूसरी बार चलाना कुछ नहीं करता। हर ड्राइव का बेवजह फिर से format नहीं। - 4096 वाले फ़ॉर्मैट सिर्फ़ मेटाडेटा के साथ हैं। 4096 + 8 फ़ॉर्मैट
Metadata Size: 0पूरा नहीं करता, इसलिए लूप चुपचाप आपको ऐसी T10-PI ड्राइव नहीं थमाएगा जो आपने माँगी नहीं।
दूसरे शब्दों में यह बंद होकर फ़ेल होता है। जब यह पक्का नहीं होता, छोड़ देता है।
Portability पर एक बात: उन lookaheads को GNU grep का -P (PCRE) मोड चाहिए। जिस सिस्टम पर grep कुछ और है, वहाँ पैटर्न किसी से मेल नहीं खाता और हर ड्राइव छोड़ दी जाती है। झुँझलाने वाला, पर कम से कम गलती सुरक्षित दिशा में होती है।
फिर भी चलाने से पहले लूप पढ़ लीजिए।
जहाँ यह मेल खाता है, वहाँ बिना और पूछे फ़ॉर्मैट करता है। nvme format --force दो बार नहीं पूछता।
इसकी जगह provisioning में है, ऐसी मशीन पर जिसकी ड्राइव में कुछ नहीं, कभी ऐसे होस्ट पर नहीं जिस पर चलता OSD, pool या VM डिस्क हो।
FreeBSD पर इसके बराबर nvmecontrol है, जहाँ -f फ़ॉर्मैट इंडेक्स है:
nvmecontrol format -f 1 nvme0ns1
SAS और SATA: openSeaChest
Seagate का openSeaChest cross-platform और open source है, और दूसरे vendors की ड्राइव पर भी चलता है।
# Find the handle
openSeaChest_Format --scan
# Ask the drive which sector sizes it will accept
openSeaChest_Format -d /dev/sg1 --showSupportedFormats
# Convert. The confirmation string is deliberately hard to type by accident.
openSeaChest_Format -d /dev/sg1 --setSectorSize 4096 \
--confirm this-will-erase-data-and-may-render-the-drive-inoperable
वह confirmation वाक्य मेरा नाटक नहीं है। यह वह शाब्दिक स्ट्रिंग है जो टूल माँगता है, और “may render the drive inoperable” वाला हिस्सा सच है। बिजली जाने से बीच में रुका low-level format ड्राइव को ऐसी हालत में छोड़ सकता है कि उसे काम करने से पहले एक और format चाहिए।
नीचे, ऑपरेशन ट्रांसपोर्ट के हिसाब से अलग है: SAS और SCSI Format Unit इस्तेमाल करते हैं, SATA Set Sector Configuration Ext, जो fast-format रास्ता है, और NVMe NVM Format। SAS ड्राइव के लिए आप Format Unit सीधे चला सकते हैं, और ध्यान दीजिए कि यह विकल्प छोटी confirmation स्ट्रिंग लेता है:
openSeaChest_Format -d /dev/sg1 --formatUnit 4096 --poll \
--confirm this-will-erase-data
दो अलग विकल्प, दो अलग confirmation स्ट्रिंग: इन्हें उल्टा लगाइए और टूल मना कर देता है।
जहाँ ड्राइव fast format सपोर्ट करती है, सेक्टर साइज़ घंटों के बजाय सेकंडों में बदलता है; ड्राइव उसके बाद अपना integrity और background काम करती है, और उस पर अपना असली डेटा लिखने से वह background समय घटता है। पूरा format शुरू से आख़िर तक शून्य लिखता है और बड़ी घूमती डिस्क पर कई घंटे से कई दिन ले सकता है।
openSeaChest_Format -d /dev/sg1 --setSectorSize 4096 --fastFormat \
--confirm this-will-erase-data-and-may-render-the-drive-inoperable
SCSI: sg_format
SCSI बोलने वाली किसी भी चीज़ के लिए sg3_utils यही काम करेगा:
# --size requires --format; expect hours on a large spinning disk
sg_format --format --size=4096 /dev/sdb
# Fast format where the drive supports it — seconds instead of hours
sg_format --format --size=4096 --ffmt=1 /dev/sdb
sg_format commit करने से पहले 15 सेकंड की उलटी गिनती देता है, जिसे --quick छोड़ देता है।
इसका डॉक्यूमेंटेशन एक ख़ास विफलता की चेतावनी भी देता है जो जानने लायक है: अगर ब्लॉक-साइज़ बदलाव सफल हो पर फिर format फ़ेल हो जाए, तो ड्राइव “format corrupt” हालत में जा सकती है और ठीक होने के लिए एक और format चाहिए।
कुछ भी बदलने से पहले
- बूट पाथ जाँचिए। बूट डिवाइस के रूप में 4Kn ड्राइव को UEFI और उसे सपोर्ट करने वाला OS चाहिए। आधुनिक Linux ठीक है। पुराना Windows नहीं, और कुछ हार्डवेयर RAID कंट्रोलर अब भी 4Kn को पूरी तरह मना करते हैं।
- ड्राइव में कुछ होने से पहले करिए। बाद में करने का मतलब है खाली करो, बदलो, वापस लाओ।
- एक कीजिए, फिर जाँचिए। एक ड्राइव बदलिए, बताए गए साइज़ पक्के कीजिए, फिर बाकी।
- घंटों की उम्मीद रखिए बिना fast format वाली घूमती डिस्क पर। जिस मशीन की आपको जल्दी वापस ज़रूरत है उस पर low-level format शुरू मत कीजिए।
आपके पास क्या है, यह जाँचना
# LOG-SEC is what the host addresses, PHY-SEC is what the medium uses
lsblk -o NAME,MODEL,SIZE,LOG-SEC,PHY-SEC
# The same, from sysfs
cat /sys/block/sda/queue/logical_block_size
cat /sys/block/sda/queue/physical_block_size
# SMART states both, and this is the clearest 512e signature there is
smartctl -a /dev/sda | grep -i "sector size"
512 bytes logical, 4096 bytes physical एक 512e ड्राइव है।
मेल खाती संख्याओं का मतलब नेटिव है: दोनों 512 हों तो 512n, दोनों 4096 हों तो 4Kn।
और जाँचिए कि पार्टीशन सच में मेल खाते हैं:
parted /dev/sda align-check optimal 1
ZFS, Ceph और वर्चुअल डिस्क
ZFS: pool बनाते वक़्त ashift=12 साफ़ तौर पर सेट कीजिए, और ड्राइव के बताए साइज़ पर भरोसा मत कीजिए, क्योंकि 512e पर वह आपको 9 बताएगी और गलत होगी। इसे बाद में बदला नहीं जा सकता।
Ceph: फ़्लैश पर BlueStore का न्यूनतम allocation साइज़ 4 KB होना चाहिए। आधुनिक Ceph का डिफ़ॉल्ट 4096 है, पर पुराने बिल्ड का डिफ़ॉल्ट ज़्यादा था, SSD पर लगभग 16 KB और HDD पर 64 KB, और यह RBD VM डिस्क के लिए बुरा है, क्योंकि वे बहुत सारी छोटी random 4 KB writes भेजती हैं और 16 या 64 KB allocation इकाई में पड़ने वाली 4 KB write write को बढ़ाती भी है और बाकी को भराव पर बर्बाद भी करती है। यह OSD बनते वक़्त तय होता है, इसलिए इसे बनाने या फिर से बनाने से पहले सेट करना होगा:
ceph config set global bluestore_min_alloc_size_ssd 4096 # new or rebuilt OSDs only
इसका साथी bluestore_min_alloc_size_hdd भी है। मौजूदा OSD वही रखते हैं जिससे वे बने थे, इसलिए इसे बदलने का मतलब उन्हें फिर से बनाना है।
वर्चुअल डिस्क: guest वही देखता है जो hypervisor दिखाता है, नीचे की ड्राइव नहीं, इसलिए VM के नीचे 4Kn ड्राइव भी guest को 512-बाइट ब्लॉक देती है जब तक आप कुछ और न कहें। स्टैक को शुरू से आख़िर तक 4K रखने का मतलब है QEMU को 4K दिखाने को कहना, जो Proxmox में /etc/pve/qemu-server/<vmid>.conf में एक raw argument लाइन है:
args: -global scsi-hd.physical_block_size=4k -global scsi-hd.logical_block_size=4096
यही लाइन असल में उन डिस्क के लिए QEMU को 4Kn पर मजबूर करती है: -global इसे VM के हर scsi-hd डिवाइस पर लगाता है, इसलिए guest को लॉजिकल और फ़िज़िकल दोनों ब्लॉक साइज़ के लिए 4096 बताया जाता है और वह उसी हिसाब से पार्टीशन और अलाइन करता है।
पूरी स्ट्रिंग को quote मत कीजिए। Proxmox args: को Text::ParseWords::shellwords से पार्स करता है, इसलिए यह:
args: "-global scsi-hd.physical_block_size=4k -global scsi-hd.logical_block_size=4096"
एक अकेले argument में सिमट जाता है: quotes माने जाते हैं और हटा दिए जाते हैं, और QEMU को चार के बजाय एक लंबा, पार्स न होने वाला विकल्प मिलता है। बिना quote के वही लाइन -global, scsi-hd.physical_block_size=4k, -global, scsi-hd.logical_block_size=4096 में बँटती है, जो आप चाहते हैं। यह आसान गलती है क्योंकि कमांड लाइन पर quote करना सही आदत है, और विफलता, एक VM जो शुरू नहीं होता और विकल्प की शिकायत करता है, quotes की ओर इशारा नहीं करती।
यह guest OS इंस्टॉल करने से पहले कीजिए। पहले से इंस्टॉल सिस्टम के नीचे डिस्क का ब्लॉक साइज़ बदलना उसे बूट न होने लायक छोड़ सकता है, क्योंकि पार्टीशन लेआउट और बूटलोडर 512-बाइट सेक्टर के लिए लिखे गए थे। यह भी ध्यान दीजिए कि args: GUI के प्रबंधन से बाहर एक expert रास्ता है, और live migration और snapshots के साथ इसका तालमेल मौजूदा Proxmox डॉक्यूमेंटेशन से फिर जाँचने लायक है।
जब guest 512 कहे और होस्ट 4K
यह वह मामला है जिसे ठीक से समझना ज़रूरी है, क्योंकि ऊपर का सारा काम करने के बाद डिफ़ॉल्ट से आपको यही मिलता है।
QEMU guest को 512-बाइट लॉजिकल ब्लॉक दिखाता है जब तक उसे कुछ और न कहा जाए, बैकिंग डिवाइस चाहे जो हो। तो आप होस्ट की हर ड्राइव को 4Kn में बदल सकते हैं, और ऊपर के VM को फिर भी 512 बताया जाएगा, और वे उस पर भरोसा करेंगे।
फिर guest 512-बाइट सीमाओं पर पार्टीशन करता है क्योंकि वह कर सकता है, और 512-बाइट IO भेजता है क्योंकि वह भेज सकता है। पर होस्ट डिवाइस के पास अब सच में 4096-बाइट लॉजिकल ब्लॉक है, और वह 512-बाइट write स्वीकार नहीं करेगा। दोनों का मेल किसी को कराना है, और वह होस्ट है: QEMU आसपास के 4 KB पढ़ता है, उनमें guest के 512 बाइट मिलाता है, और पूरी चीज़ वापस लिखता है।
आपने इम्युलेशन हटाया नहीं है। आपने उसे ड्राइव के फ़र्मवेयर से हटाकर अपने hypervisor में डाल दिया है, जहाँ वह ड्राइव के चक्रों के बजाय होस्ट CPU और एक bounce buffer का पड़ता है।
cache=none के साथ यह कोई हल्का जुर्माना भी नहीं है। 4Kn डिवाइस पर O_DIRECT 4 KB-अलाइन्ड ऑफ़सेट और लंबाई माँगता है, इसलिए 4K से छोटी guest write सीधे आगे नहीं भेजी जा सकती: IO भेजने से पहले ही QEMU में अलाइनमेंट ठीक करना पड़ता है।
और मिसअलाइनमेंट का मामला एक परत ऊपर वापस आता है। 512-बाइट बारीकी पर पार्टीशन किया गया guest अपनी 4 KB फ़ाइलसिस्टम writes ऐसे ऑफ़सेट पर रखता है जो होस्ट के दो 4 KB ब्लॉक में फैलते हैं, इसलिए हर एक होस्ट पर दो read-modify-write बन जाती है। वही विफलता जो खुली 512e ड्राइव पर मिसअलाइन्ड पार्टीशन की है, बस अब यह एक VM के अंदर हो रही है जहाँ कोई इसे ढूँढ नहीं रहा।
तो नियम यह है: अगर होस्ट 4Kn है, तो guest को भी 4K दिखाइए, और OS डालने से पहले कीजिए।
अपवाद guest सपोर्ट है, जो 512e के होने की पूरी वजह है:
- Linux guests 4Kn को बिना झंझट संभालते हैं।
- Windows Windows 8 और Server 2012 से आगे डेटा वॉल्यूम के लिए 4Kn सपोर्ट करता है, और 4Kn से बूट करने के लिए UEFI चाहिए।
- कुछ भी पुराना, Windows 7 और उससे पहले, 4Kn बिल्कुल नहीं कर सकता। उनके लिए 512 दिखाने वाली वर्चुअल डिस्क उन्हें चलाने की कीमत है, और मेल होस्ट कराएगा। अगर यह मायने रखता है, तो उन guests को अपनी सबसे तेज़ tier के बजाय ऐसे स्टोरेज पर रखिए जहाँ यह आपको सबसे कम पड़े।
Guest के अंदर से जाँचिए कि उसे असल में क्या मिला:
lsblk -o NAME,LOG-SEC,PHY-SEC
4Kn होस्ट पर वहाँ 512 का मतलब है कि ऊपर वाला मेल हर अनअलाइन्ड write पर हो रहा है।
संदर्भ
- OpenZFS — Workload Tuning —
ashift, क्यों2^ashiftएक vdev पर सबसे छोटा संभव IO है, और यह टिप्पणी कि “many devices misreport their sector sizes” nvme-formatman page —--lbaf,--namespace-id,--sesऔर--forcesg_formatman page —--formatके साथ--size, fast-format विकल्प, और format-corrupt चेतावनी- openSeaChest — Seagate की open-source ड्राइव यूटिलिटी,
--setSectorSizeऔर--showSupportedFormatsसमेत - openSeaChest wiki — Format, Fast Format, And Sector Sizes — कौन सा ट्रांसपोर्ट कौन सा कमांड इस्तेमाल करता है, और fast format कब लागू होता है
nvmecontrol(8)— FreeBSD का समकक्ष- Linux block layer documentation — कर्नेल लॉजिकल और फ़िज़िकल ब्लॉक साइज़ को कैसे मॉडल करता है