df full, du తక్కువ: కనిపించని స్థలాన్ని కనుగొనడం

df పూర్తి స్థలాన్ని చూపి, du వేరే ఫలితాన్ని చూపడానికి కారణం

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

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

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

df లెక్కించేది, du లెక్కించేది

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

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

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

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

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

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

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

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

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

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

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

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

ఇప్పుడు ఒక fileను సృష్టించండి. దాని పరిమాణం machine స్వయంగా నివేదించే free space ఆధారంగా ఉంటుంది. కాబట్టి మీ వద్ద ఉన్న disk పరిమాణానికి ఈ demonstration సరిపోతుంది.

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

$(...) అనేది command substitution. Shell దానిలోని commandను run చేసి, దాని outputను free విలువగా ఉపయోగిస్తుంది. ఈ syntax మీకు కొత్తదైతే, bashలో command substitutionలో దాని గురించి పూర్తి వివరణ ఉంది. fallocate వాస్తవ blocksను వాటిలో bytes రాయకుండానే reserve చేస్తుంది. అందుకే అది వెంటనే పూర్తవుతుంది. దీనికి మద్దతు లేని 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కు అందిస్తుంది. sleep దాన్ని openగా ఉంచుతుంది. $! ఆ background job యొక్క process IDను కలిగి ఉంటుంది. Descriptor ఇంకా openగా ఉన్నప్పుడే rm ఆ file పేరు తొలగిస్తుంది.

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 గా గుర్తిస్తుంది. కాబట్టి దాన్ని పట్టుకుని ఉన్నదాన్ని కనుగొనాలంటే, 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 తో run చేయాలి. లేకపోతే మీ స్వంత processes కు మాత్రమే /proc/<pid>/fd చదవగలరు. find నడుస్తున్న సమయంలో ముగిసే processes వల్ల వచ్చే అనవసరమైన సందేశాలను 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 వరకూ అనుసరిస్తుంది. అందువల్ల %s ఇక పేరు లేని ఫైల్ యొక్క size ను చూపిస్తుంది. ఆ సంఖ్యపై sorting చేస్తే అతిపెద్ద ఫైల్ మొదట కనిపిస్తుంది.

తర్వాత ఆ 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 పేరు మరియు అది ఎంతకాలంగా run అవుతోందో చూపిస్తుంది. stat -L deleted inode యొక్క size మరియు allocated block count ను ముద్రిస్తుంది. ఇవి రెండూ కలిసి ముఖ్యమైన ప్రశ్నకు సమాధానం ఇస్తాయి: ఈ ఫైల్‌ను ఏ service సజీవంగా ఉంచుతోంది?

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

రీబూట్ లేకుండా స్థలాన్ని తిరిగి పొందండి

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

ఆ డేటా ఇంకా అవసరమైతే ముందుగా దాన్ని బయటకు కాపీ చేయండి. descriptor path ను చదవడం ద్వారా live 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 ఫైల్ యొక్క ప్రస్తుత చివరికి వెళ్తుంది. అలా open చేయకపోతే process తన పాత write offset ను ఉంచుకుంటుంది. అందువల్ల దాని తదుపరి write ఫైల్‌లో చాలా దూరంలో పడుతుంది, ముందు భాగంలో hole తో ఫైల్‌ను మళ్లీ సృష్టిస్తుంది. hole కు allocation ఉండదు. కాబట్టి blocks free గానే ఉంటాయి, అలాగే df ఇప్పుడే తిరిగి ఇచ్చిన space ను ఉంచుతుంది. మారేది size మాత్రమే: process write చేసిన తర్వాత మళ్లీ sudo stat -L "/proc/$pid/fd/$n" నడపండి. అప్పుడు పాత size తో పాటు దానికి సరిపోని block count ను చూపిస్తుంది. size కూడా సున్నా నుంచి ప్రారంభం కావాలంటే process ను restart చేయండి.

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

sudo systemctl kill -s USR1 nginx

ఇది systemd unit యొక్క ప్రధాన process గా నమోదు చేసిన process కు signal పంపుతుంది. అందువల్ల daemon వాస్తవంగా ప్రారంభమయ్యే విధానానికి సరిపోని తప్పు Type= ను ప్రకటించిన unit మీ signal ను తొలగించిన file ను ఎప్పుడూ పట్టుకోని process కు పంపవచ్చు. అప్పుడు space అలాగే మిగిలిపోతుంది.

నాలుగవది, unit ను restart చేయండి. sudo systemctl restart <unit> పాత process పట్టుకున్న ప్రతి descriptor ను close చేస్తుంది. అందువల్ల 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

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

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

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

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

inodes ముగిశాయి, blocks కాదు

ఒక inode ఒక ఫైల్‌కు సంబంధించిన metadata ను కలిగి ఉంటుంది. Filesystem సృష్టించేటప్పుడు ext4 స్థిర సంఖ్యలో inodes ను సృష్టిస్తుంది. అందువల్ల filesystem లో free blocks ఉన్నప్పటికీ 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 ను ఒక level దిగువన మళ్లీ అమలు చేయండి. ఫైళ్లు సృష్టిస్తున్న tree వరకు ఈ విధానాన్ని కొనసాగించండి. మీ du --inodes కు మద్దతు ఇవ్వకపోతే, sudo find /var -xdev -type f | wc -l subtree ను నెమ్మదిగా లెక్కిస్తుంది.

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

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

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

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

నడుస్తున్న server లో అసలు files ను కనుగొనడానికి root filesystem ను మరోసారి వేరే చోట మౌంట్ చేయండి. bind 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 కింద కనిపించని ఏవైనా files mount point కింద దాగి ఉన్నాయి. పని పూర్తయిన తర్వాత bind mount ను unmount చేయండి. లేకపోతే -x లేకుండా తరువాత చేసే du అదే files ను రెండుసార్లు లెక్కిస్తుంది.

root కోసం కేటాయించిన blocks

ext4 తన blocks లో కొంత భాగాన్ని root user కోసం కేటాయిస్తుంది. దీనివల్ల disk పూర్తిగా నిండినా root login చేసి machine ను సరిచేయగలదు. సాధారణ 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 లో చూపిస్తుంది. అందువల్ల వాటి నిష్పత్తిని నేరుగా లెక్కించవచ్చు. df సాధారణ user ఇంకా ఉపయోగించగల స్థలంగా available column ను చూపిస్తుంది. అందుకే used మరియు available మొత్తము size కంటే తక్కువగా ఉంటుంది. ఆ తేడానే reserve.

దాన్ని sudo tune2fs -m <percent> "$dev" తో మార్చండి. ఈ మార్పు వెంటనే అమలవుతుంది. Remount అవసరం లేదు. ప్రత్యేక data filesystem లో reserve ను తగ్గించడం సమంజసం. అయితే root filesystem లో root ఇంకా write చేయగలిగేంత స్థలాన్ని ఉంచండి. ఖాళీ స్థలం పూర్తిగా లేని root filesystem ను repair చేయడం చాలా కష్టం. ఇది మిమ్మల్ని login చేయలేకపోవడం నుంచి కూడా కాపాడుతుంది. ఖాళీ స్థలం లేని filesystem లో authorized_keys కు జోడించే key పూర్తిగా లేదా అసలు write కాకపోవచ్చు. అప్పుడు తదుపరి login Permission denied (publickey) అనే error తో విఫలమవుతుంది. దీనికి key తో సంబంధం ఉండకపోవచ్చు. tune2fs ext2, ext3 మరియు ext4 పై పనిచేస్తుంది. XFS లో దీనికి సమానమైన setting లేదు.

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

du లోని నాలుగు విధానాల వల్ల తప్పుగా కనిపించే totals వస్తాయి.

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

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

నిజమైన ఘటనలో అనుసరించాల్సిన క్రమం

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

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

FAQ

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

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

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 జాబితా చేస్తుంది. అది print చేసే path లో process ID ఉంటుంది. ఆ descriptor paths లో ఒకదానిపై sudo stat -Lc %s run చేస్తే దాని size కనిపిస్తుంది. వాటిని sort చేసి అవసరమైనదాన్ని ఎంచుకోవచ్చు. దీనికి ఏ package అవసరం లేదు. Free space లేని filesystem పై package install చేయడం విఫలమయ్యే అవకాశం ఉన్నందున ఇది ముఖ్యమైనది.

Process ను ఆపకుండా space ను ఖాళీ చేయవచ్చా?

కొన్నిసార్లు చేయవచ్చు. Descriptor ద్వారా అదే inode ను sudo truncate -s 0 /proc/<pid>/fd/<n> చేరుకుని, process నడుస్తూనే దాని blocks ను release చేస్తుంది. 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 చూపిస్తుంది. మీరు write వాస్తవంగా ఉపయోగిస్తున్న filesystem నే చదువుతున్నారో నిర్ధారించండి. ఎందుకంటే ప్రత్యేకమైన /boot లేదా /var, / తో సంబంధం లేకుండా స్వతంత్రంగా నిండిపోవచ్చు.

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

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