df పూర్తి, du కాదు: దాగిన డిస్క్ స్థలాన్ని కనుగొనండి

df పూర్తి అని, du వేరుగా చూపడానికి కారణం

df డిస్క్ పూర్తిగా నిండిందని చూపిస్తుంది. అయితే du ఆ స్థలాన్ని గుర్తించలేకపోవచ్చు. కారణం, తొలగించిన ఫైల్‌ను ఒక process ఇప్పటికీ తెరిచి ఉంచడమే. ఫైల్‌ను తొలగించినప్పుడు directory నుంచి దాని పేరు మాత్రమే తొలగుతుంది. ఆ inode కు సూచించే చివరి open file descriptor మూసిన తర్వాతే data blocks విడుదలవుతాయి. du ఫైల్ పేర్లను అనుసరిస్తుంది, కాబట్టి అది ఏదీ లెక్కించదు. df filesystem కు ఎన్ని blocks allocate అయ్యాయో అడుగుతుంది. అందువల్ల పేరు లేకపోయినా ఇంకా తెరిచి ఉన్న ఫైల్‌ను అది లెక్కిస్తుంది.

ఇప్పటికే install అయి ఉన్న tools తో సాధారణ Ubuntu VPS పై ఈ పరిస్థితిని ఈ guide పునరుత్పత్తి చేస్తుంది. /proc ద్వారా ఆ ఫైల్‌ను పట్టుకుని ఉన్న process ను గుర్తిస్తుంది. Reboot చేయకుండా స్థలాన్ని విడుదల చేస్తుంది. ఇదే లక్షణానికి దారితీసే ఇతర కారణాలు కూడా తరువాత చూడబడతాయి: ఖాళీ entries లేని inode table, mount point కింద దాగి ఉన్న files, మరియు root కోసం reserve చేసిన blocks.

ప్రతి command ను అమలు చేసి, మీ స్వంత output ను పరిశీలించండి. విలువలు మీ disk పై ఆధారపడి ఉంటాయి. అందువల్ల guide లో చూపిన సంఖ్యతో పోల్చకుండా, మీ స్వంత machine పై before మరియు after ఫలితాలను పోల్చండి.

df ఏమి లెక్కిస్తుంది, du ఏమి లెక్కిస్తుంది

df (disk free) ప్రతి mounted filesystem ను దాని స్వంత లెక్కల కోసం ప్రశ్నిస్తుంది: ఎన్ని blocks ఉన్నాయి, ఎన్ని allocated అయ్యాయి, ఇంకా ఎన్ని free గా ఉన్నాయి. ఇది ఎప్పుడూ directory ను తెరవదు. ఏ directory entry కూడా సూచించని file కు చెందిన blocks సహా, allocated అయిన ప్రతి block ఈ లెక్కలో ఉంటుంది.

du (disk usage) దీనికి విరుద్ధంగా పనిచేస్తుంది. మీరు ఇచ్చిన path వద్ద ప్రారంభమై, directories ను చదివి, కనిపించిన ప్రతి entry పై stat నిర్వహించి, blocks మొత్తాన్ని కలుపుతుంది. పేరు లేని file దీనికి కనిపించదు. చదవడానికి అనుమతి లేని directory కూడా కనిపించదు. అందుకే సాధారణ user పొందే total, root పొందే total కంటే తక్కువగా ఉంటుంది. పోలిక ఆధారంగా ఏ నిర్ణయానికైనా రాకముందు du ను sudo కింద అమలు చేయండి.

ఈ రెండింటినీ పోల్చిన ప్రతిసారీ రెండు options ముఖ్యమైనవి.

• -x లో du ను ఒకే filesystem కు పరిమితం చేస్తుంది. ఇది లేకపోతే / కింద mounted అయిన ప్రతి filesystem లోకి du / ప్రవేశించి, df / ఎప్పుడూ కొలవని total ను చూపిస్తుంది.
• -s ప్రతి directory కు ఒక line చూపించడానికి బదులుగా, ప్రతి argument కు ఒక summary line చూపిస్తుంది.

దీంతో మీరు పరిశీలిస్తున్న filesystem పై పక్కపక్కనే అమలు చేయాల్సిన జత సిద్ధమవుతుంది.

df -h /
sudo du -xhs / 2>/dev/null

df వెంటనే సమాధానం ఇస్తుంది. పెద్ద filesystem పై du కు నిమిషాలు పట్టవచ్చు, ఎందుకంటే మార్గంలోని ప్రతి file పై stat నిర్వహించాలి. రెండు totals మధ్య చాలా తేడా ఉన్నప్పుడు, మరియు du ను root గా -x తో అమలు చేసినప్పుడు, మిగిలిన space పేరు లేని ఏదో allocated వస్తువుకు చెందుతుంది.

ఉద్దేశపూర్వకంగా అసమతుల్యతను పునరుత్పత్తి చేయండి

దీన్ని ఒక test VPS పై చేయండి. దిగువన ఉన్నవి అన్నీ bash మరియు coreutils మాత్రమే, కాబట్టి ఏదీ install చేయాల్సిన అవసరం లేదు.

/var/tmp ను కలిగి ఉన్న filesystem యొక్క ప్రారంభ స్థితిని నమోదు చేయండి.

cd /var/tmp
df -h .
df --output=used -B1 .

రెండవ command rounding లేకుండా ఉపయోగించిన bytes ను చూపిస్తుంది. అందువల్ల చివరలో చేసే తనిఖీ ఖచ్చితంగా ఉంటుంది.

ఇప్పుడు ఒక file సృష్టించండి. దాని పరిమాణం machine స్వయంగా నివేదించే ఖాళీ స్థలం నుంచి వస్తుంది. కాబట్టి మీ వద్ద ఉన్న ఏ disk అయినా ఈ ప్రదర్శనకు సరిపోతుంది.

free=$(df --output=avail -B1 . | tail -n 1)
fallocate -l $((free / 10)) ghost.bin
ls -l ghost.bin
df -h .

$(...) అనేది command substitution. shell దానిలోని command ను నడిపి, దాని output ను free విలువగా ఉపయోగిస్తుంది. ఈ syntax మీకు కొత్త అయితే, bashలో command substitution లో దాని గురించి సమగ్రంగా వివరించబడింది. fallocate bytes రాయకుండానే వాస్తవ blocks ను కేటాయిస్తుంది. అందుకే ఇది వెంటనే పూర్తవుతుంది. దీనికి మద్దతు లేని filesystem పై command విఫలమవుతుంది. అప్పుడు head -c $((free / 10)) /dev/zero > ghost.bin bytes ను రాస్తూ అదే పని చేస్తుంది.

ఈ df -h . ను మీరు నమోదు చేసిన దానితో పోల్చండి. used column పెరిగి ఉంటుంది, available column తగ్గి ఉంటుంది.

ఇప్పుడు మరో process నుంచి file ను open గా ఉంచి, తరువాత దాన్ని delete చేయండి.

sleep infinity < ghost.bin &
holder=$!
rm ghost.bin
ls -l ghost.bin
df -h .
sudo du -xhs . 2>/dev/null

మొత్తం విధానంలో కీలకమైనది redirection. sleep infinity < ghost.bin & ఒక background process ను ప్రారంభిస్తుంది. దాని standard input ఆ file అవుతుంది. అందువల్ల shell file ను open చేసి, descriptor ను sleep కు అందిస్తుంది. అది file ను open గానే ఉంచుతుంది. $! ఆ background job యొక్క process ID ను కలిగి ఉంటుంది. descriptor ఇంకా open లో ఉన్నప్పటికీ rm ఆ పేరు తొలగిస్తుంది.

Output ను చదవండి. ls ఆ file ను కనుగొనలేడు, ఎందుకంటే పేరు తొలగిపోయింది. du ప్రారంభ స్థితికి సమీపంగా తిరిగి ఉంటుంది, ఎందుకంటే అది పేర్లను పరిశీలిస్తుంది. Blocks ఇంకా allocated గానే ఉండటంతో df మారలేదు. ఇప్పుడు filesystem మరియు directory tree పరస్పరం సరిపోలడం లేదు. వాటి మధ్య ఉన్న తేడానే మీరు ఇప్పుడే delete చేసిన file.

తొలగించిన ఫైల్‌ను పట్టుకున్న ప్రాసెస్‌ను కనుగొనండి

ప్రతి open file descriptor /proc/<pid>/fd/ కింద, అది సూచించే ఫైల్‌కు symbolic link గా కనిపిస్తుంది. ఫైల్ unlink అయినప్పుడు, ఆ link target ను kernel deleted గా గుర్తిస్తుంది. కాబట్టి holder ను కనుగొనడం అంటే, target లో ఆ marker ఉన్న link ను కనుగొనడం.

sudo find /proc/[0-9]*/fd -lname '*(deleted)' -printf '%p -> %l\n' 2>/dev/null

-lname symbolic link పేరుకు బదులుగా దాని target ను సరిపోల్చుతుంది, %p descriptor path ను ముద్రిస్తుంది, %l అది సూచించే దాన్ని ముద్రిస్తుంది. ముద్రించే path లో process ID రెండవ భాగం. దీన్ని sudo తో అమలు చేయండి. లేకపోతే మీ స్వంత processes కు సంబంధించిన /proc/<pid>/fd మాత్రమే చదవగలరు. find పరిశీలిస్తున్న సమయంలో ముగిసే processes వల్ల వచ్చే అనవసరమైన output ను stderr redirect తొలగిస్తుంది.

Busy server ఏ సమయంలోనైనా అనేక deleted files ను పట్టుకుని ఉండవచ్చు. వాటిలో ఎక్కువవి చిన్నవిగా, హానికరం కానివిగా ఉంటాయి. వాటిని size ఆధారంగా sort చేయండి. అప్పుడు ఆసక్తికరమైనవి మాత్రమే పైభాగంలో ఉంటాయి.

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 | head

stat -L link ను స్వయంగా inode వరకు follow చేస్తుంది. అందువల్ల పేరు లేని ఫైల్ size ను %s చూపిస్తుంది. ఆ సంఖ్యపై sort చేయడం వల్ల అతిపెద్ద ఫైల్ మొదట కనిపిస్తుంది.

తర్వాత ఆ descriptor వెనుక ఉన్న process ను గుర్తించండి. ఆ జాబితాలో పైభాగంలోని path లో మీకు అవసరమైన రెండు numbers ఉంటాయి. ముందుగా వాటిని variables లో ఉంచండి. PID మరియు N స్థానాల్లో మీ listing చూపించిన విలువలను పెట్టండి.

pid=PID
n=N
ps -o pid,user,etime,args -p "$pid"
sudo stat -L "/proc/$pid/fd/$n"

ps program పేరును చూపించి, అది ఎంతకాలంగా నడుస్తుందో తెలియజేస్తుంది. stat -L deleted inode యొక్క size మరియు allocated block count ను ముద్రిస్తుంది. ఇవి కలిసి ముఖ్యమైన ప్రశ్నకు సమాధానం ఇస్తాయి: ఈ ఫైల్‌ను ఏ service ఇంకా అందుబాటులో ఉంచుతోంది.

Machine లో ఇప్పటికే lsof ఉంటే, link count సున్నాకు తగ్గిన open files ను sudo lsof +L1 జాబితా చేస్తుంది. వాటి sizes ను ఒకే table లో చూపిస్తుంది. Minimal Ubuntu image లో ఇది ఉండదు. Free space లేని filesystem పై package install చేయడం కూడా విఫలమవచ్చు. అందువల్ల ఎల్లప్పుడూ పనిచేసే పద్ధతి /proc walk.

రీబూట్ లేకుండా స్థలాన్ని ఖాళీ చేయండి

రీబూట్ చేస్తే సమస్య పరిష్కారమవుతుంది, కానీ అది మొదటి చర్యగా సరైనది కాదు: దాంతో సేవ ఆగిపోతుంది, ఆధారాలు నశిస్తాయి. ముందుగా ప్రయత్నించాల్సిన క్రమంలో నాలుగు తక్కువ ప్రభావం కలిగిన మార్గాలు ఉన్నాయి.

ఆ డేటా ఇంకా కావాలంటే ముందుగా దాన్ని కాపీ చేయండి. descriptor path ను చదివితే ప్రస్తుతం ఉపయోగంలో ఉన్న inode చదవబడుతుంది.

sudo cp /proc/<pid>/fd/<n> /root/recovered.log

తొలగించిన ఫైల్‌ను తిరిగి పొందడం సులభంగా ఉండే ఏకైక సందర్భం ఇదే. అందుకే rm -rf తో తొలగించిన ఫైళ్లను తిరిగి పొందడం అనే విధానం మొదటగా ఏదైనా process ఆ ఫైల్‌ను ఇంకా open గా ఉంచిందా అని అడుగుతుంది. చివరి descriptor close అయిన తర్వాత ఆ మార్గం ఉండదు.

రెండవది, descriptor ద్వారా ఫైల్‌ను ఖాళీ చేయండి. /proc path అదే inode కు దారి తీస్తుంది. అందువల్ల దాన్ని truncate చేస్తే process నడుస్తూనే blocks విడుదలవుతాయి.

sudo truncate -s 0 "/proc/$pid/fd/$n"
df -h /

writer ఫైల్‌ను append mode లో open చేసినప్పుడు ఇది సరిగ్గా పనిచేస్తుంది. అప్పుడు ప్రతి write ప్రస్తుత file end కు వెళ్తుంది. అలా open చేయకపోతే process తన పాత write offset ను కొనసాగిస్తుంది. అందువల్ల దాని తదుపరి write ఫైల్‌లో చాలా దూరంలో పడుతుంది, ముందు భాగంలో hole తో ఫైల్‌ను మళ్లీ సృష్టిస్తుంది. Hole కు blocks allocate కావు. కాబట్టి blocks free గానే ఉంటాయి, అలాగే df ఇప్పుడే తిరిగి ఇచ్చిన స్థలాన్ని చూపిస్తూనే ఉంటుంది. మారేది size మాత్రమే: process write చేసిన తర్వాత మళ్లీ sudo stat -L "/proc/$pid/fd/$n" అమలు చేయండి. అప్పుడు అది పాత size ను చూపిస్తుంది, కానీ దానికి సరిపోని block count ను పక్కనే చూపిస్తుంది. Size కూడా zero నుంచి ప్రారంభం కావాలంటే process ను restart చేయండి.

మూడవది, logs ను మళ్లీ open చేయమని service ను అడగండి. Log file ను దాని కింద తొలగించినా open గా ఉంచే daemon ఈ సమస్యకు సాధారణ వాస్తవ రూపం. చాలా daemons signal అందుకున్నప్పుడు తమ log files ను మళ్లీ open చేస్తాయి: nginx SIGUSR1 ను, rsyslog SIGHUP ను ఉపయోగిస్తాయి. ఊహించకుండా, మీరు నిర్వహిస్తున్న daemon documentation ను పరిశీలించండి. తప్పు daemon కు తప్పు signal పంపితే అది ఆగిపోవచ్చు.

sudo systemctl kill -s USR1 nginx

నాలుగవది, unit ను restart చేయండి. sudo systemctl restart <unit> పాత process open గా ఉంచిన ప్రతి descriptor ను close చేస్తుంది. అందువల్ల blocks ఖచ్చితంగా తిరిగి వస్తాయి. పై ఉదాహరణలో 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

ఫైల్ సృష్టించకముందు నమోదు చేసిన విలువతో used bytes ను పోల్చండి. రెండు విలువలు మళ్లీ సరిపోతాయి, అలాగే find ఇక మీ descriptor ను report చేయదు. సమస్యను కనుగొన్న అదే command తో ధృవీకరించడం కొనసాగించాల్సిన మంచి అలవాటు.

ఆ విలువ ఎలా మారుతుందో చూడటానికి df ను మళ్లీ మళ్లీ చేతితో అమలు చేయడం కంటే సులభమైన మార్గం ఉంది. watch ఒక command ను నిర్ణీత విరామంలో మళ్లీ అమలు చేస్తుంది మరియు output ను అదే స్థానంలో మళ్లీ ముద్రిస్తుంది. అందువల్ల స్థలం తిరిగి వచ్చినప్పుడు used column ఎలా మారుతుందో watch df -h / చూపిస్తుంది.

మొత్తాలు సరిపోలినా disk ఇంకా full గా ఉన్నప్పుడు

df మరియు root du -x ఒకదానితో ఒకటి సరిపోలితే, deleted file కారణం కాదు. మిగిలిన కారణాలు వేర్వేరు రకాలవి. ప్రతి కారణానికి ప్రత్యేకంగా తనిఖీ చేసే విధానం ఉంటుంది.

inodes అయిపోయాయి, blocks కాదు

ఒక inode ఒక ఫైల్‌కు సంబంధించిన metadata ను కలిగి ఉంటుంది. Filesystem తయారైనప్పుడు ext4 నిర్దిష్ట సంఖ్యలో inodes ను సృష్టిస్తుంది. అందువల్ల ఇంకా free blocks ఉన్నప్పటికీ filesystem లో inodes అయిపోవచ్చు. అప్పుడు df -h లో స్థలం కనిపిస్తున్నా కొత్త ఫైళ్ల సృష్టి విఫలమవుతుంది.

df -h /
df -i /

మొదటి command blocks ను లెక్కిస్తుంది. రెండవది inodes ను లెక్కిస్తుంది. రెండింటిలోని use column ను పోల్చండి. Block use తక్కువగా ఉండి inode use పరిమితికి చేరితే, చాలా చిన్న ఫైళ్లు చాలా ఎక్కువగా ఉండటం సమస్య.

df ఒకే invocation లో -i మరియు --output ను తిరస్కరిస్తుంది. అందువల్ల raw counts ను చదవాలన్నా లేదా మరో command కు అందించాలన్నా, inode fields ను పేరుతో ఎంచుకుని -i ను వదిలేయండి.

df --output=itotal,iused,iavail,ipcent /

ఈ columns df -i చూపించే అదే accounting ను, విడిగా విశ్లేషించగల రూపంలో అందిస్తాయి.

Bytes కు బదులుగా entries ను లెక్కించి ఫైళ్లను కనుగొనండి.

sudo du --inodes -x -d 1 / 2>/dev/null | sort -rn | head

పైభాగంలో కనిపించిన directory పై ఇదే command ను ఒక స్థాయి దిగువన మళ్లీ అమలు చేయండి. ఫైళ్లను సృష్టిస్తున్న tree ను చేరే వరకు కొనసాగించండి. మీ du కు --inodes మద్దతు లేకపోతే, sudo find /var -xdev -type f | wc -l subtree ను నెమ్మదిగా లెక్కిస్తుంది.

పరిష్కారం ఆ ఫైళ్లను తొలగించడం లేదా తరలించడం. ఇప్పటికే ఉన్న ext4 filesystem కు inodes ను జోడించలేరు, ఎందుకంటే mkfs సమయంలో వాటి సంఖ్య స్థిరంగా నిర్ణయించబడుతుంది. అందువల్ల ఆ సంఖ్యను పెంచాలంటే filesystem ను మళ్లీ సృష్టించి backup నుంచి restore చేయాలి. XFS అవసరానికి అనుగుణంగా inodes ను కేటాయిస్తుంది. కాబట్టి అదే విధంగా fixed ceiling ను ఎదుర్కోదు. Containers నడిపే machine రెండు limits ను సాధారణం కంటే త్వరగా చేరుతుంది, ఎందుకంటే image layers లో చాలా చిన్న ఫైళ్లు ఉంటాయి. ఆ machine లో VPS లో Docker disk usage ను prune చేయడం ప్రత్యేక పరిష్కారం. ఇది filesystem పై సాధారణ sweep కంటే చాలా ఎక్కువ స్థలాన్ని తిరిగి పొందుతుంది.

మౌంట్ పాయింట్ కింద దాగి ఉన్న స్థలం

ఏదైనా filesystem ను ఒక directory పై mount చేయడానికి ముందు, ఆ directory లో files ఉండవచ్చు. ఆ directory పై filesystem ను mount చేసినా, కింద ఉన్న files ఉన్న చోటే ఉంటాయి: అవి ఇప్పటికీ స్థలాన్ని ఆక్రమిస్తాయి, df లో ఇప్పటికీ లెక్కించబడతాయి, కానీ పేరుతో ఇక అందుబాటులో ఉండవు. Mount వాటిని కప్పివేస్తుంది కాబట్టి du వాటిని చూడలేదు.

దీన్ని tmpfs తో చూపించవచ్చు. దీనికి అదనపు disk స్థలం అవసరం లేదు. ఈ భాగాన్ని అమలు చేయడానికి mount చేయడానికి అనుమతి ఉన్న machine అవసరం. అందువల్ల ఇది 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 ఒక ఖాళీ directory ని చూపిస్తుంది. Copy ఎక్కడికీ వెళ్లలేదు: అది ఇప్పటికీ root filesystem లోనే ఉంది, మీరు unmount చేసిన వెంటనే మళ్లీ కనిపిస్తుంది. ఇప్పుడు, ఎవరో ఒకరు ఆ path పై volume ను mount చేయడానికి ముందు ఒక నెలపాటు ఒక service అక్కడ logs రాసిందని ఊహించండి.

నడుస్తున్న server లో అసలు files ను కనుగొనడానికి root filesystem ను రెండోసారి వేరే స్థానంలో mount చేయండి. Bind mount, దాని లోపల mount చేసిన filesystems ను మినహాయించి, ఒక filesystem ను చూపిస్తుంది.

sudo mkdir -p /mnt/rootcheck
sudo mount --bind / /mnt/rootcheck
sudo du -xhs /mnt/rootcheck/* 2>/dev/null | sort -h
sudo umount /mnt/rootcheck

ఆ listing లో కనిపించి, సాధారణ path కింద కనిపించని ప్రతి అంశం mount point కింద దాగి ఉంటుంది. పని పూర్తయిన తర్వాత bind mount ను unmount చేయండి. లేకపోతే, తరువాత du ను -x లేకుండా అమలు చేస్తే అదే files రెండుసార్లు లెక్కించబడతాయి.

root కోసం రిజర్వ్ చేసిన బ్లాక్‌లు

ext4 తన బ్లాక్‌లలో కొంత భాగాన్ని root user కోసం కేటాయిస్తుంది. దీనివల్ల disk పూర్తిగా నిండిపోయినా root login చేసి machine ను repair చేయగలదు. సాధారణ user గా నడిచే process ముందుగా ఈ పరిమితిని తాకుతుంది, అయితే df లో ఇంకా కొంత స్థలం కనిపిస్తుంది. Default ను ఊహించకుండా, మీ filesystem లోని setting ను చదవండి.

dev=$(df --output=source / | tail -n 1)
sudo tune2fs -l "$dev" | grep -i 'block count'

ఇది మొత్తం block count మరియు reserved block count ను ఒకే units లో చూపిస్తుంది. అందువల్ల వాటి మధ్య ratio ను నేరుగా లెక్కించవచ్చు. df available column ను సాధారణ user ఇంకా ఉపయోగించగల స్థలంగా చూపిస్తుంది. అందుకే used మరియు available కలిపిన మొత్తం size కంటే తక్కువగా ఉంటుంది. ఆ తేడానే reserve.

దీనిని sudo tune2fs -m <percent> "$dev" తో మార్చండి. ఈ మార్పు వెంటనే అమలవుతుంది. Remount అవసరం లేదు. ప్రత్యేక data filesystem పై reserve ను తగ్గించడం సమంజసం. అయితే root filesystem పై root ఇంకా రాయగలిగేంత స్థలాన్ని ఉంచండి. Root filesystem లో అసలు ఖాళీ లేకపోతే దాన్ని repair చేయడం చాలా కష్టం. tune2fs ext2, ext3 మరియు ext4 పై పనిచేస్తుంది. XFS లో దీనికి సమానమైన setting లేదు.

du ఒక్కదానితో తప్పుదారి పట్టించే సందర్భాలు

du కు సంబంధించిన నాలుగు అలవాట్లు తప్పుగా కనిపించే మొత్తాలను ఇస్తాయి.

• Hard links: అనేక పేర్లు ఒకే inode ను సూచించినా du ఆ inode ను ఒక్కసారి మాత్రమే లెక్కిస్తుంది. అందువల్ల hard links తో నిండిన tree, దాని ఫైళ్ల మొత్తానికి తగ్గ పరిమాణాన్ని చూపిస్తుంది.
• Sparse files: కేటాయించిన blocks ను du చూపిస్తుంది. apparent size ను ls -l చూపిస్తుంది. మరో విలువను చూడటానికి --apparent-size జోడించండి.
• Permissions: సాధారణ user గా నడిపితే, చదవలేని వాటిని du దాటవేస్తుంది. అందువల్ల మొత్తం తక్కువగా కనిపిస్తుంది. ఇది ముద్రించే errors ను ప్రజలు /dev/null కు redirect చేసి, ఇక పరిశీలించడం ఆపేస్తారు.
• Filesystem boundaries: -x లేకుండా, du / / కింద mounted అయిన ప్రతి filesystem ను లెక్కిస్తుంది. అందువల్ల దాని మొత్తం df / చూపించే మొత్తాన్ని మించవచ్చు.

df కు కూడా తెలుసుకోవాల్సిన ఒక అలవాటు ఉంది. ఇది ప్రతి filesystem ను విడిగా చూపిస్తుంది. కాబట్టి విఫలమైన write లక్ష్యంగా ఉన్న ఖచ్చితమైన path పై దీన్ని నడపండి. Kernel packages పేరుకుపోతున్న కొద్దీ ప్రత్యేకమైన /boot తన స్వంత షెడ్యూల్ ప్రకారం నిండుతుంది. Ubuntu లో పాత kernels తొలగించడం అనేది / లో స్థలం ఖాళీ చేయడం కంటే వేరే పని.

నిజమైన incident కోసం పని క్రమం

1. విఫలమైన write లక్ష్యంగా చేసుకున్న filesystem పై `df -h <path> మరియు df -i <path> అమలు చేయండి. అలవాటుగా /` పై అమలు చేయవద్దు.
2. `sudo du -xh -d 1 <mountpoint> 2>/dev/null | sort -h` అమలు చేసి, తరువాత ఎక్కువ స్థలం ఆక్రమించిన directory లోకి వెళ్లండి.
3. `du ద్వారా df ఉపయోగంలో ఉందని చూపించిన స్థలాన్ని వివరించలేకపోతే, ఇంకా open గా ఉన్న deleted files కోసం /proc` లో search చేయండి.
4. రెండూ సరిపోతే, filesystem ను మరొక స్థానంలో bind mount చేసి, mount point కింద ఉన్న files కోసం చూడండి.
5. పరిమితికి చేరింది inode వినియోగం అయితే, bytes కాకుండా files ను లెక్కించండి.

ఇక్కడ ప్రతి దశలో మీరు output ను చదవగలిగే command ఉంటుంది. సమస్యను అంచనా వేయడం కాకుండా సరిచేయడంలో ఇదే తేడా.

FAQ

df డిస్క్ నిండినట్లు చూపుతున్నప్పుడు du చాలా తక్కువగా ఎందుకు చూపుతుంది?

ఒక process దాన్ని open చేసి ఉంచిన సమయంలో file తొలగించబడటం సాధారణ కారణం. file ను తొలగిస్తే దాని directory entry తొలగిపోతుంది. అందువల్ల du కు పరిశీలించడానికి పేరు ఉండదు, కాబట్టి దాన్ని లెక్కించడం ఆపుతుంది. చివరి descriptor close అయ్యే వరకు inode మరియు దాని blocks allocated గానే ఉంటాయి. allocated blocks ను df లెక్కిస్తుంది. లక్ష్యం deleted గా గుర్తించబడిన symbolic links కోసం /proc/<pid>/fd ను search చేస్తే, ఆ file మరియు దాన్ని పట్టుకొని ఉన్న process రెండూ కనిపిస్తాయి. ఈ పోలికను నమ్మే ముందు, మీరు du ను root గా మరియు -x తో run చేశారో నిర్ధారించండి. సాధారణ user చదవలేని directories ను నిశ్శబ్దంగా దాటవేస్తుంది.

lsof లేకుండా ఇంకా open గా ఉన్న deleted file ను ఎలా కనుగొనాలి?

Open descriptors కు kernel నిర్వహించే record ను ఉపయోగించండి. పేరు లేని file ను సూచించే ప్రతి descriptor ను sudo find /proc/[0-9]*/fd -lname '*(deleted)' -printf '%p -> %l\n' 2>/dev/null జాబితా చేస్తుంది. అది ముద్రించే path లో process ID ఉంటుంది. ఆ descriptor paths లో ఒకదానిపై sudo stat -Lc %s run చేస్తే దాని size కనిపిస్తుంది. వాటిని sort చేసి అవసరమైనదాన్ని ఎంచుకోవచ్చు. దీనికి package ఏదీ అవసరం లేదు. Free space లేని filesystem పై package install చేయడం విఫలమయ్యే అవకాశం ఉన్నందున ఇది ముఖ్యమైనది.

process ను terminate చేయకుండా space ను విడుదల చేయవచ్చా?

కొన్ని సందర్భాల్లో చేయవచ్చు. Descriptor ద్వారా అదే inode ను sudo truncate -s 0 /proc/<pid>/fd/<n> చేరుకుని, process నడుస్తూనే దాని blocks ను విడుదల చేస్తుంది. Process file ను append mode లో open చేసినప్పుడు ఇది అత్యంత శుభ్రమైన విధానం. అప్పుడు writes ఎల్లప్పుడూ ప్రస్తుత చివరికి వెళ్తాయి. అలా కాకపోతే write offset పాత స్థానంలోనే ఉంటుంది. తదుపరి write ముందుభాగంలో hole ఉన్న file ను మళ్లీ సృష్టిస్తుంది. అందువల్ల చూపించే size తిరిగి పెరుగుతుంది, కానీ hole కింద ఉన్న blocks free గానే ఉంటాయి. Unit ను restart చేయడం లేదా documentation లో పేర్కొన్న signal తో logs ను మళ్లీ open చేయమని దానికి signal పంపడం సరైన పరిష్కారం. దీంతో sparse file మిగలదు.

df free space చూపుతున్నా writes విఫలమవుతున్నాయి. ఇంకేమి కారణం కావచ్చు?

అదే path పై df -i తో inodes ను తనిఖీ చేయండి. Free blocks ఉన్నా free inodes లేకపోతే filesystem కొత్త files ను తిరస్కరిస్తుంది. ext4 filesystem పై write non-root user గా నడుస్తుందో తనిఖీ చేయండి. Reserved blocks మాత్రమే మిగిలి ఉంటే ఇది కారణం కావచ్చు. Device పై sudo tune2fs -l run చేస్తే అది కనిపిస్తుంది. మీరు write వాస్తవంగా target చేస్తున్న filesystem నే చదువుతున్నారో నిర్ధారించండి. ప్రత్యేకమైన /boot లేదా /var, / తో సంబంధం లేకుండా స్వతంత్రంగా నిండిపోవచ్చు.

df కంటే du పెద్ద total ను ఎందుకు చూపుతుంది?

-x లేకుండా du మీరు ఇచ్చిన path కింద mounted అయిన ప్రతి filesystem లోకి ప్రవేశిస్తుంది. అందువల్ల అది అనేక filesystems ను కలిపి లెక్కిస్తుంది. అయితే df ఒక filesystem ను మాత్రమే వివరిస్తుంది. Bind mounts సమస్యను మరింత పెంచుతాయి. ఒకే files అవి కనిపించే ప్రతి path కింద ఒక్కోసారి లెక్కించబడతాయి. -x ను జోడించి du ను ఒకే filesystem లో ఉంచండి. రెండు commands ఒకే విషయాన్ని వివరించేలా df కు అదే path ఇవ్వండి.