df फुल, du कम: डिस्क स्पेस कहां गया?
df फुल और du कम दिखे तो /proc से डिलीटेड लेकिन खुले file descriptor को खोजें। Ubuntu VPS में बिना रीबूट जगह खाली करें और inode व mount कारण भी जांचें।
df डिस्क फुल क्यों बताता है जबकि du कुछ और दिखाता है
df डिस्क को फुल रिपोर्ट करता है जबकि du जगह नहीं ढूंढ पाता क्योंकि कोई प्रोसेस अभी भी एक ऐसी फाइल को होल्ड किए हुए है जिसे डिलीट किया जा चुका है। किसी फाइल को डिलीट करने से उसका नाम डायरेक्टरी से हट जाता है। डेटा ब्लॉक्स तभी रिलीज होते हैं जब उस inode को पॉइंट करने वाला आखिरी ओपन फाइल डिस्क्रिप्टर बंद हो जाता है। du नामों को ट्रैक करता है, इसलिए यह कुछ भी काउंट नहीं करता। df फाइलसिस्टम से पूछता है कि कितने ब्लॉक्स एलोकेटेड हैं, इसलिए यह उस फाइल को भी काउंट करता है जिसका अब कोई नाम नहीं है।
यह गाइड एक साधारण Ubuntu VPS पर इसे दोहराती है, पहले से इंस्टॉल किए गए टूल्स का उपयोग करती है, /proc के माध्यम से होल्ड करने वाले प्रोसेस को ढूंढती है, और बिना रीबूट किए जगह खाली करती है। इसी लक्षण के अन्य कारण निम्नलिखित हैं: बिना फ्री एंट्री वाली inode टेबल, माउंट पॉइंट के नीचे दबी फाइलें, और root के लिए आरक्षित ब्लॉक्स।
प्रत्येक कमांड चलाएं और अपना आउटपुट पढ़ें। मान आपकी डिस्क पर निर्भर करते हैं, इसलिए गाइड में छपे आंकड़ों से तुलना करने के बजाय अपनी मशीन पर पहले और बाद की स्थिति की तुलना करें।
df और du क्या गिनते हैं
df (disk free) प्रत्येक mounted filesystem से उसका अपना हिसाब मांगता है: कितने blocks मौजूद हैं, कितने आवंटित (allocated) हैं, और कितने खाली हैं। यह कभी भी किसी directory को open नहीं करता है। इसका उत्तर हर आवंटित block को कवर करता है, जिसमें वे blocks भी शामिल हैं जो किसी ऐसी file से संबंधित हैं जिसकी कोई directory entry नहीं है।
du (disk usage) इसके विपरीत काम करता है। यह आपके द्वारा दिए गए path से शुरू होता है, directories को पढ़ता है, हर entry की stats लेता है, और blocks को जोड़ता है। बिना नाम वाली file इसके लिए अदृश्य होती है। इसी तरह, कोई भी ऐसी directory जिसे पढ़ने की अनुमति नहीं है, वह भी अदृश्य रहती है, यही कारण है कि एक सामान्य user को root की तुलना में कम total मिलता है। तुलना से कोई भी निष्कर्ष निकालने से पहले du को sudo के अंतर्गत चलाएं।
जब भी आप दोनों की तुलना करते हैं, तो दो options मायने रखते हैं।
-x,duको एक ही filesystem पर सीमित रखता है। इसके बिना,du /उस filesystem में भी चला जाता है जो/के नीचे mounted है और ऐसा total देता है जिसेdf /कभी माप ही नहीं रहा था।-sप्रति directory एक line के बजाय प्रति argument एक summary line print करता है।
यह आपको उस filesystem पर side by side चलाने के लिए सही जोड़ा देता है जिसकी आप जांच करना चाहते हैं।
df -h /
sudo du -xhs / 2>/dev/nulldf तुरंत उत्तर देता है। du एक बड़े filesystem पर मिनटों का समय लेता है, क्योंकि यह रास्ते में आने वाली हर file की stats लेता है। जब दोनों totals में बड़ा अंतर हो, और du को root के रूप में -x के साथ चलाया गया हो, तो इसका मतलब है कि गायब space ऐसी किसी चीज़ को आवंटित है जिसका कोई नाम नहीं है।
जानबूझकर मिसमैच उत्पन्न करना
इसे एक test VPS पर करें। नीचे दी गई सभी चीजें bash और coreutils हैं, इसलिए कुछ भी install करने की आवश्यकता नहीं है।
उस filesystem की शुरुआती स्थिति रिकॉर्ड करें जिसमें /var/tmp मौजूद है।
cd /var/tmp
df -h .
df --output=used -B1 .दूसरा command बिना rounding के उपयोग किए गए bytes को print करता है, जिससे अंत में की जाने वाली जाँच सटीक रहती है।
अब एक file बनाएँ। इसका आकार मशीन द्वारा रिपोर्ट की गई खाली जगह से लिया गया है, ताकि यह प्रदर्शन आपकी डिस्क के अनुसार हो सके।
free=$(df --output=avail -B1 . | tail -n 1)
fallocate -l $((free / 10)) ghost.bin
ls -l ghost.bin
df -h .$(...) कमांड सब्स्टीट्यूशन है: shell इसके अंदर के command को चलाता है, और output free का मान बन जाता है। यदि यह syntax आपके लिए नया है, तो bash में कमांड सब्स्टीट्यूशन इसे विस्तार से समझाता है। fallocate बिना कुछ लिखे वास्तविक blocks को आरक्षित (reserve) कर लेता है, इसीलिए यह तुरंत पूरा हो जाता है। जिस filesystem पर यह समर्थित नहीं है, वहाँ यह command विफल हो जाता है, और head -c $((free / 10)) /dev/zero > ghost.bin bytes को लिखकर वही काम करता है।
इस df -h . की तुलना उस स्थिति से करें जिसे आपने रिकॉर्ड किया था। 'used' कॉलम बढ़ गया है और 'available' कॉलम घट गया है।
अब file को किसी अन्य process से खुला रखें, फिर उसे delete कर दें।
sleep infinity < ghost.bin &
holder=$!
rm ghost.bin
ls -l ghost.bin
df -h .
sudo du -xhs . 2>/dev/nullredirection ही पूरी तरकीब है। sleep infinity < ghost.bin & एक background process शुरू करता है जिसका standard input वह file है, इसलिए shell file को खोलता है और descriptor को sleep को सौंप देता है, जो इसे खुला रखता है। $! उस background job की process ID रखता है। rm फिर file का नाम हटा देता है जबकि descriptor अभी भी खुला रहता है।
output पढ़ें। ls file को नहीं ढूँढ पा रहा है, क्योंकि नाम हट चुका है। du वापस अपनी शुरुआती स्थिति के करीब है, क्योंकि यह नामों को स्कैन करता है। df नहीं बदला है, क्योंकि blocks अभी भी आवंटित (allocated) हैं। filesystem और directory tree अब एक-दूसरे से असहमत हैं, और उनके बीच का अंतर वही file है जिसे आपने अभी delete किया है।
डिलीट की गई फाइल को होल्ड करने वाली प्रोसेस ढूँढना
हर ओपन फाइल डिस्क्रिप्टर /proc/<pid>/fd/ के अंतर्गत उस फाइल के सिम्बॉलिक लिंक के रूप में दिखाई देता है जिसे वह रेफर करता है। जब फाइल को unlink कर दिया जाता है, तो kernel उस लिंक के टारगेट को 'deleted' के रूप में मार्क कर देता है। इसलिए होल्डर को खोजने का मतलब है ऐसे लिंक को खोजना जिसका टारगेट यह मार्कर रखता हो।
sudo find /proc/[0-9]*/fd -lname '*(deleted)' -printf '%p -> %l\n' 2>/dev/null-lname सिम्बॉलिक लिंक के नाम के बजाय उसके टारगेट से मैच करता है, %p डिस्क्रिप्टर पाथ को प्रिंट करता है, और %l यह प्रिंट करता है कि वह कहाँ पॉइंट कर रहा है। प्रोसेस ID उसके द्वारा प्रिंट किए गए पाथ का दूसरा एलिमेंट होता है। इसे sudo के साथ चलाएं, क्योंकि अन्यथा आप केवल अपनी प्रोसेस के लिए /proc/<pid>/fd पढ़ पाएंगे। stderr रीडायरेक्ट उन प्रोसेस से आने वाले शोर को हटा देता है जो find के चलने के दौरान समाप्त हो जाती हैं।
एक व्यस्त सर्वर किसी भी समय कई डिलीट की गई फाइलों को होल्ड करके रखता है, और उनमें से अधिकांश छोटी और हानिरहित होती हैं। उन्हें साइज के अनुसार सॉर्ट करें ताकि केवल महत्वपूर्ण फाइलें ही सबसे ऊपर रहें।
sudo bash -c 'for fd in /proc/[0-9]*/fd/*; do
target=$(readlink "$fd" 2>/dev/null) || continue
case "$target" in
*"(deleted)") echo "$(stat -Lc %s "$fd" 2>/dev/null) $fd $target" ;;
esac
done' | sort -rn | headstat -L लिंक को सीधे inode तक फॉलो करता है, इसलिए %s उस फाइल का साइज रिपोर्ट करता है जिसका अब कोई नाम नहीं है। उस नंबर पर सॉर्ट करने से सबसे बड़ी फाइल सबसे पहले आ जाती है।
फिर विनिंग डिस्क्रिप्टर के पीछे की प्रोसेस की पहचान करें। उस लिस्ट के टॉप पर मौजूद पाथ में वे दोनों नंबर होते हैं जिनकी आपको आवश्यकता है, इसलिए उन्हें पहले वेरिएबल्स में डालें, और PID तथा N को अपनी लिस्टिंग में प्रिंट हुए नंबरों से बदलें।
pid=PID
n=N
ps -o pid,user,etime,args -p "$pid"
sudo stat -L "/proc/$pid/fd/$n"ps प्रोग्राम का नाम बताता है और यह दिखाता है कि वह कितनी देर से चल रहा है। stat -L डिलीट किए गए inode का साइज और एलोकेटेड ब्लॉक काउंट प्रिंट करता है। ये दोनों मिलकर उस महत्वपूर्ण प्रश्न का उत्तर देते हैं: कौन सी सर्विस इस फाइल को जीवित रख रही है।
यदि मशीन में पहले से lsof मौजूद है, तो sudo lsof +L1 उन ओपन फाइलों को लिस्ट करता है जिनका लिंक काउंट जीरो हो गया है और एक टेबल में उनके साइज दिखाता है। यह एक मिनिमल Ubuntu इमेज पर मौजूद नहीं होता है, और बिना खाली स्पेस वाले फाइलसिस्टम पर पैकेज इंस्टॉल करना खुद विफल हो सकता है, इसलिए /proc वॉक वह वर्जन है जो हमेशा काम करता है।
Reboot किए बिना जगह खाली करना
Reboot करने से समस्या हल हो जाती है, लेकिन यह पहला कदम नहीं होना चाहिए: इससे service बंद हो जाती है और सबूत नष्ट हो जाते हैं। चार बेहतर विकल्प मौजूद हैं, जिन्हें आप इस क्रम में आजमा सकते हैं।
सबसे पहले, यदि आपको डेटा की आवश्यकता है तो उसे कॉपी कर लें। Descriptor path को पढ़ने से live inode पढ़ा जाता है।
sudo cp /proc/<pid>/fd/<n> /root/recovered.logयह एकमात्र ऐसी स्थिति है जहाँ delete की गई file को वापस पाना आसान है, इसीलिए rm -rf से delete की गई files को recover करना इस सवाल से शुरू होता है कि क्या कोई process अभी भी file को open रखे हुए है। एक बार जब अंतिम descriptor बंद हो जाता है, तो वह रास्ता खत्म हो जाता है।
दूसरा, descriptor के माध्यम से file को खाली करें। /proc path उसी inode तक ले जाता है, इसलिए उसे truncate करने से blocks मुक्त हो जाते हैं जबकि process चलती रहती है।
sudo truncate -s 0 "/proc/$pid/fd/$n"
df -h /यह तब ठीक से काम करता है जब writer ने file को append mode में open किया हो, क्योंकि तब हर write operation file के वर्तमान अंत में होता है। यदि ऐसा नहीं है, तो process अपना पुराना write offset बनाए रखती है, जिससे उसका अगला write file में काफी आगे होता है और शुरुआत में एक hole के साथ file फिर से बन जाती है। Hole allocate नहीं होता है, इसलिए blocks खाली रहते हैं और df उस जगह को बनाए रखता है जो उसने अभी वापस की है। जो वापस आता है वह केवल size है: process के write करने के बाद फिर से sudo stat -L "/proc/$pid/fd/$n" चलाएं, और यह block count के बगल में पुराना size दिखाएगा जो अब उससे मेल नहीं खाता। जब आप चाहते हैं कि size भी शून्य से शुरू हो, तो process को restart करें।
तीसरा, service से अपनी logs को फिर से open करने के लिए कहें। जिस daemon की log file उसके नीचे से delete कर दी गई हो, वह इस समस्या का एक सामान्य वास्तविक रूप है। कई daemons signal मिलने पर अपनी log files को फिर से open करते हैं: nginx SIGUSR1 का उपयोग करता है और rsyslog SIGHUP का। अनुमान लगाने के बजाय अपने सामने मौजूद daemon के लिए documentation देखें, क्योंकि गलत daemon को गलत signal भेजने से वह बंद हो सकता है।
sudo systemctl kill -s USR1 nginxयह signal उस process को भेजता है जिसे systemd unit के मुख्य process के रूप में record करता है, इसलिए एक ऐसी unit जो daemon के शुरू होने के तरीके के लिए गलत Type= घोषित करती है, वह आपके signal को ऐसी process तक पहुँचा सकती है जिसने कभी deleted file को hold नहीं किया था, और जगह वहीं बनी रहती है।
चौथा, unit को restart करें। sudo systemctl restart <unit> पुरानी process द्वारा रखे गए हर descriptor को बंद कर देता है, इसलिए blocks निश्चित रूप से वापस आ जाते हैं। ऊपर दिए गए demonstration के लिए holder एक sleep है जिसे आपने स्वयं शुरू किया था, इसलिए उसे समाप्त करना ही पर्याप्त है।
kill $holder
df -h .
df --output=used -B1 .
sudo find /proc/[0-9]*/fd -lname '*(deleted)' -printf '%p -> %l\n' 2>/dev/nullउपयोग किए गए bytes की तुलना उस value से करें जिसे आपने file बनाने से पहले record किया था। वे फिर से मेल खाते हैं, और find अब आपके descriptor की रिपोर्ट नहीं करता है। समस्या खोजने वाले उसी command के साथ verify करना एक अच्छी आदत है।
उस value को बदलते हुए देखना बार-बार हाथ से df चलाने से आसान है। watch एक निश्चित अंतराल पर command को दोहराता है और output को उसी स्थान पर फिर से print करता है, इसलिए watch df -h / दिखाता है कि जैसे-जैसे जगह वापस आती है, used column बदलता रहता है।
जब totals मेल खाते हैं और disk फिर भी full है
यदि df और root du -x एक-दूसरे से सहमत हैं, तो इसमें कोई deleted file शामिल नहीं है। शेष कारण अलग प्रकार के हैं, और प्रत्येक की अपनी जाँच होती है।
Blocks खत्म नहीं हुए, inodes खत्म हो गए हैं
एक inode किसी एक फाइल के मेटाडेटा को होल्ड करता है। जब फाइलसिस्टम बनाया जाता है, तो ext4 प्रत्येक ब्लॉक ग्रुप में inodes की संख्या को फिक्स कर देता है। इसलिए, किसी भी निश्चित आकार पर कुल संख्या स्थिर रहती है, और फाइलसिस्टम में खाली ब्लॉक्स होने के बावजूद inodes खत्म हो सकते हैं। ऐसी स्थिति में नई फाइलें नहीं बन पातीं, भले ही df -h में जगह दिखाई दे रही हो।
df -h /
df -i /पहली कमांड ब्लॉक्स की गिनती करती है और दूसरी inodes की। प्रत्येक के use कॉलम की तुलना करें। यदि ब्लॉक का उपयोग कम है और inode का उपयोग अपनी सीमा पर है, तो इसका मतलब है कि बहुत सारी छोटी फाइलों की संख्या बहुत अधिक है।
df एक ही इनवोकेशन में -i और --output को स्वीकार नहीं करता है। इसलिए, जब आप रॉ काउंट्स को पढ़ना चाहते हैं या किसी अन्य कमांड को देना चाहते हैं, तो inode फील्ड्स को नाम से चुनें और -i को हटा दें।
df --output=itotal,iused,iavail,ipcent /ये कॉलम वही अकाउंटिंग डेटा रखते हैं जिसे df -i प्रिंट करता है, एक ऐसे प्रारूप में जिसे आप अलग-अलग कर सकते हैं।
बाइट्स के बजाय एंट्रीज की गिनती करके फाइलों को खोजें।
sudo du --inodes -x -d 1 / 2>/dev/null | sort -rn | headसबसे ऊपर आने वाली डायरेक्टरी पर एक स्तर नीचे जाकर उसी कमांड को दोहराएं, जब तक कि आप उस ट्री तक न पहुंच जाएं जो फाइलें बना रहा है। यदि आपका du, --inodes को सपोर्ट नहीं करता है, तो sudo find /var -xdev -type f | wc -l सबट्री को धीमे तरीके से काउंट करेगा।
इसका समाधान उन फाइलों को डिलीट करना या मूव करना है। फाइलसिस्टम को बढ़ाने से भी inodes बढ़ते हैं: जब resize2fs एक ext4 फाइलसिस्टम को एक्सटेंड करता है, तो हर नया ब्लॉक ग्रुप उतनी ही संख्या में inodes लाता है जितनी mkfs ने सेट की थी, इसलिए कुल संख्या आपके द्वारा जोड़ी गई जगह के अनुपात में बढ़ती है। mkfs जिस चीज को ठीक करता है वह inodes और स्पेस का अनुपात है, इसलिए बिना स्पेस बढ़ाए संख्या बढ़ाने का मतलब अभी भी फाइलसिस्टम को सघन inode सेटिंग के साथ फिर से बनाना और बैकअप से रिस्टोर करना ही है। XFS जरूरत पड़ने पर inodes एलोकेट करता है, इसलिए इसमें इस तरह की कोई निश्चित सीमा नहीं होती। कंटेनर चलाने वाली मशीनें अधिकांश अन्य मशीनों की तुलना में इन दोनों सीमाओं तक जल्दी पहुंच जाती हैं, क्योंकि इमेज लेयर्स में कई छोटी फाइलें होती हैं। ऐसी मशीन पर VPS पर Docker के डिस्क उपयोग को प्रून करना इसका विशिष्ट समाधान है, और यह फाइलसिस्टम की सामान्य सफाई की तुलना में कहीं अधिक जगह खाली करता है।
माउंट पॉइंट के नीचे छिपा हुआ स्पेस
किसी डायरेक्टरी पर कुछ भी माउंट करने से पहले उसमें फाइलें हो सकती हैं। उस डायरेक्टरी पर एक फाइलसिस्टम माउंट करने पर नीचे मौजूद फाइलें वहीं बनी रहती हैं: वे अभी भी एलोकेटेड होती हैं, df द्वारा गिनी जाती हैं, और अब नाम से एक्सेस नहीं की जा सकतीं। du उन्हें नहीं देख सकता क्योंकि माउंट उन्हें ढक लेता है।
इसे tmpfs के साथ दिखाएं, जिसके लिए किसी अतिरिक्त डिस्क की आवश्यकता नहीं होती। इस भाग के लिए ऐसी मशीन की आवश्यकता है जहाँ आपको माउंट करने की अनुमति हो, इसलिए यह KVM VPS पर काम करता है।
sudo mkdir -p /srv/covered
sudo cp /etc/services /srv/covered/
ls /srv/covered
sudo mount -t tmpfs tmpfs /srv/covered
ls /srv/covered
sudo umount /srv/covered
ls /srv/coveredबीच वाला ls एक खाली डायरेक्टरी दिखाता है। कॉपी कहीं नहीं गई: यह अभी भी रूट फाइलसिस्टम पर है, और अनमाउंट करते ही वापस आ जाती है। अब एक ऐसी सर्विस की कल्पना करें जिसने किसी के द्वारा उस पर वॉल्यूम माउंट करने से पहले एक महीने तक उस पाथ पर लॉग किया हो।
चल रहे सर्वर पर वास्तविक स्थिति का पता लगाने के लिए, रूट फाइलसिस्टम को कहीं और दूसरी बार माउंट करें। एक बाइंड माउंट एक फाइलसिस्टम को उसके अंदर माउंट की गई अन्य फाइलसिस्टम्स के बिना दिखाता है।
sudo mkdir -p /mnt/rootcheck
sudo mount --bind / /mnt/rootcheck
sudo du -xhs /mnt/rootcheck/* 2>/dev/null | sort -h
sudo umount /mnt/rootcheckजो कुछ भी उस लिस्टिंग में दिखाई देता है लेकिन सामान्य पाथ के नीचे नहीं, वह एक माउंट पॉइंट के नीचे दबा हुआ है। काम पूरा होने पर बाइंड माउंट को अनमाउंट करें, अन्यथा -x के बिना बाद वाला du उन्हीं फाइलों को दो बार गिन लेगा।
root के लिए आरक्षित ब्लॉक्स
ext4 फाइलसिस्टम root यूजर के लिए अपने कुछ ब्लॉक्स आरक्षित रखता है, ताकि डिस्क भर जाने पर भी root को लॉग इन करने और मशीन को रिपेयर करने में कोई बाधा न आए। एक सामान्य यूजर के रूप में चलने वाली प्रक्रिया सबसे पहले इस सीमा से टकराती है, जबकि df में अभी भी थोड़ी जगह दिखाई देती है। डिफ़ॉल्ट मान मान लेने के बजाय अपने फाइलसिस्टम पर इस सेटिंग को पढ़ें।
dev=$(df --output=source / | tail -n 1)
sudo tune2fs -l "$dev" | grep -i 'block count'यह कुल ब्लॉक काउंट और आरक्षित ब्लॉक काउंट को समान इकाइयों में प्रिंट करता है, इसलिए उनके बीच का अनुपात सीधा होता है। df उपलब्ध कॉलम को उस स्थान के रूप में रिपोर्ट करता है जिसे एक सामान्य यूजर अभी भी उपयोग कर सकता है, यही कारण है कि 'used' और 'available' का योग कुल 'size' से कम आता है। यह अंतर ही आरक्षित स्थान है।
इसे sudo tune2fs -m <percent> "$dev" के साथ बदलें। यह बदलाव तुरंत लागू होता है और इसके लिए remount की आवश्यकता नहीं होती। एक अलग डेटा फाइलसिस्टम पर आरक्षित स्थान को कम करना उचित है। रूट फाइलसिस्टम पर, इतना स्थान अवश्य छोड़ें कि root लिख सके, क्योंकि पूरी तरह से भरी हुई रूट फाइलसिस्टम को रिपेयर करना बहुत कठिन होता है। यह वह सुरक्षा है जो आपको सिस्टम से बाहर होने से बचाती है: यदि फाइलसिस्टम में जगह नहीं बची है, तो authorized_keys में जोड़ी गई कोई की (key) अधूरी लिखी जा सकती है या बिल्कुल नहीं लिखी जाएगी, और अगली बार लॉग इन करने पर Permission denied (publickey) का एरर आएगा, जिसका कारण की (key) से संबंधित नहीं होगा। tune2fs, ext2, ext3 और ext4 पर काम करता है। XFS में इसके समकक्ष कोई सेटिंग नहीं है।
जहाँ केवल du आपको गलत निष्कर्ष तक पहुँचा सकता है
du की चार आदतों के कारण ऐसे totals मिलते हैं जो गलत लगते हैं।
- Hard links:
duकिसी inode को केवल एक बार count करता है, भले ही कई names उससे जुड़े हों। इसलिए hard links से भरी tree अपनी files के sum से कम report करती है। - Sparse files:
duवास्तव में allocated blocks report करता है, जबकिls -lapparent size report करता है। दूसरा number देखने के लिए--apparent-sizeजोड़ें। - Permissions: ordinary user के रूप में चलाने पर
duउन items को skip करता है जिन्हें वह read नहीं कर सकता और कम total report करता है। इससे print होने वाली errors को लोग/dev/nullपर redirect करके पढ़ना बंद कर देते हैं। - Filesystem boundaries:
-xके बिनाdu /,/के नीचे mounted हर filesystem को count करता है। इसलिए इसका totaldf /द्वारा report किए गए total से अधिक हो सकता है।
df की भी एक उपयोगी आदत है। यह प्रत्येक filesystem को अलग-अलग report करता है। इसलिए इसे उसी exact path पर चलाएँ जहाँ failing write target कर रहा है। Kernel packages जमा होने पर एक अलग /boot अपने schedule के अनुसार भरता है। / पर space clear करना Ubuntu पर पुराने kernels हटाने से अलग काम है।
किसी वास्तविक घटना के लिए कार्य-प्रणाली
df -h <path>औरdf -i <path>को उस filesystem पर चलाएं जहाँ failed write हो रही थी, न कि केवल आदतवश/पर।sudo du -xh -d 1 <mountpoint> 2>/dev/null | sort -hचलाएं, फिर सबसे बड़ी directory के अंदर जाएं।- यदि
duयह नहीं बता पा रहा है किdfके अनुसार कितनी जगह इस्तेमाल हुई है, तो उन deleted files को खोजने के लिए/procका उपयोग करें जो अभी भी open हैं। - यदि दोनों के आंकड़े मेल खाते हैं, तो filesystem को कहीं और bind mount करें और देखें कि क्या कोई file mount point के नीचे दबी हुई है।
- यदि समस्या inode की सीमा तक पहुँचने की है, तो bytes के बजाय files की संख्या गिनें।
यहाँ हर चरण में एक command है जिसका output आप पढ़ सकते हैं। यही इस समस्या को ठीक करने और केवल अनुमान लगाने के बीच का अंतर है।
FAQ
df डिस्क को फुल क्यों दिखाता है जबकि du बहुत कम जगह घेरता है?
इसका सामान्य कारण वह फाइल है जिसे डिलीट तो कर दिया गया है, लेकिन किसी प्रोसेस ने उसे अभी भी open रखा है। फाइल को हटाने से उसकी directory entry हट जाती है, इसलिए du के पास गिनने के लिए कोई नाम नहीं बचता और वह उसे छोड़ देता है। inode और उसके blocks तब तक allocated रहते हैं जब तक कि आखिरी descriptor बंद न हो जाए, और df उन्हीं allocated blocks को गिनता है। /proc/<pid>/fd में उन symbolic links को खोजें जिनका target 'deleted' मार्क किया गया है; इससे आपको फाइल और उसे होल्ड करने वाली प्रोसेस दोनों मिल जाएंगे। तुलना पर भरोसा करने से पहले सुनिश्चित करें कि आपने du को root के रूप में और -x के साथ चलाया है, क्योंकि एक साधारण user उन directories को चुपचाप छोड़ देता है जिन्हें वह पढ़ नहीं सकता।
lsof के बिना डिलीट की गई लेकिन open फाइल को कैसे खोजें?
kernel के open descriptors के रिकॉर्ड का उपयोग करें। sudo find /proc/[0-9]*/fd -lname '*(deleted)' -printf '%p -> %l\n' 2>/dev/null उन सभी descriptors को लिस्ट करता है जो ऐसी फाइल की ओर इशारा कर रहे हैं जिसका कोई नाम नहीं है, और प्रोसेस ID उस path के अंदर होती है जिसे यह प्रिंट करता है। उन descriptor paths में से किसी एक पर sudo stat -Lc %s चलाने से उसका size पता चल जाता है, जिससे आप उन्हें sort करके महत्वपूर्ण फाइल चुन सकते हैं। इसके लिए किसी पैकेज की आवश्यकता नहीं होती, जो तब उपयोगी है जब खाली जगह न होने के कारण नया पैकेज इंस्टॉल करना विफल हो सकता है।
क्या मैं प्रोसेस को kill किए बिना जगह खाली कर सकता हूँ?
कभी-कभी। sudo truncate -s 0 /proc/<pid>/fd/<n> descriptor के माध्यम से उसी inode तक पहुँचता है और प्रोसेस के चलते रहने के दौरान ही उसके blocks को release कर देता है। यह तब सबसे अच्छा काम करता है जब प्रोसेस ने फाइल को append mode में open किया हो, क्योंकि उसका write हमेशा अंत में होता है। यदि ऐसा नहीं है, तो write offset वहीं रहता है और अगला write फाइल को शुरुआत में एक hole के साथ फिर से बना देता है, जिससे रिपोर्ट किया गया size वापस बढ़ जाता है जबकि hole के नीचे के blocks खाली रहते हैं। यूनिट को restart करना, या उसके documentation में बताए गए signal के साथ उसे logs फिर से open करने का निर्देश देना ही वह समाधान है जिससे कोई sparse file पीछे नहीं बचती।
df खाली जगह दिखाता है लेकिन write विफल हो जाता है। और क्या कारण हो सकता है?
उसी path पर df -i के साथ inodes की जाँच करें, क्योंकि जिस filesystem में blocks तो खाली हैं लेकिन inodes नहीं, वह नई फाइलें स्वीकार नहीं करेगा। जाँचें कि क्या write एक non-root user द्वारा ऐसे ext4 filesystem पर किया जा रहा है जहाँ केवल reserved blocks बचे हैं, जिसे डिवाइस पर sudo tune2fs -l चलाने से देखा जा सकता है। यह भी सुनिश्चित करें कि आप उसी filesystem को पढ़ रहे हैं जिसे write target कर रहा है, क्योंकि एक अलग /boot या /var, / से स्वतंत्र रूप से भरते हैं।
du, df की तुलना में बड़ा total क्यों दिखाता है?
-x के बिना du आपके द्वारा दिए गए path के अंतर्गत mount किए गए हर filesystem में चला जाता है, इसलिए यह कई filesystems को जोड़ देता है जबकि df केवल एक का वर्णन करता है। Bind mounts इसे और खराब कर देते हैं, क्योंकि एक ही फाइल हर उस path के नीचे गिनी जाती है जहाँ वह दिखाई देती है। du को एक ही filesystem पर सीमित रखने के लिए -x जोड़ें, और df को वही path दें, ताकि दोनों commands एक ही चीज़ का वर्णन करें।