Stai rintracciando dove lo spazio su disco è andato su Linux?

Quando si amministrano i sistemi Linux, mi trovo spesso a lottare per rintracciare il colpevole dopo che una partizione è piena. Normalmente uso du / | sort -nrma su un filesystem di grandi dimensioni questo richiede molto tempo prima che vengano restituiti i risultati.

Inoltre, questo di solito ha successo nell'evidenziare l'autore del reato peggiore, ma mi sono spesso ritrovato a ricorrere dusenza i sort casi più sottili e quindi ho dovuto esplorare l'output.

Preferirei una soluzione a riga di comando che si basa su comandi Linux standard poiché devo amministrare un bel po 'di sistemi e l'installazione di nuovo software è una seccatura (soprattutto quando si è a corto di spazio su disco!)

Prova ncduun eccellente analizzatore di utilizzo del disco da riga di comando:

Non andare direttamente a du /. Usa dfper trovare la partizione che ti fa male, quindi prova i ducomandi.

Uno che mi piace provare è

# U.S.
du -h <dir> | grep '[0-9\.]\+G'
# Others
du -h <dir> | grep '[0-9\,]\+G'

perché stampa le dimensioni in "forma leggibile dall'uomo". A meno che tu non abbia partizioni davvero piccole, cercare le directory nei gigabyte è un filtro abbastanza buono per quello che vuoi. Questo richiederà del tempo, ma a meno che tu non abbia impostato le quote, penso che sarà esattamente così.

Come sottolinea @jchavannes nei commenti, l'espressione può essere più precisa se trovi troppi falsi positivi. Ho incorporato il suggerimento, che lo rende migliore, ma ci sono ancora falsi positivi, quindi ci sono solo compromessi (expr più semplice, risultati peggiori; expr più complesso e più lungo, risultati migliori). Se hai troppe piccole directory visualizzate nell'output, modifica di conseguenza la tua regex. Per esempio,

grep '^\s*[0-9\.]\+G'

è ancora più preciso (non verrà elencata alcuna directory <1GB).

Se fare avere quote, è possibile utilizzare

quota -v

per trovare utenti che stanno eseguendo il hogging del disco.

Per una prima occhiata, usa la vista "riepilogo" di du:

du -s /*

L'effetto è di stampare la dimensione di ciascuno dei suoi argomenti, ovvero ogni cartella radice nel caso sopra.

Inoltre, sia GNUdu che BSDdu possono essere limitati in profondità ( ma POSIX duno! ):

• GNU (Linux, ...):

  du --max-depth 3

• BSD (macOS, ...):

  du -d 3
  

Ciò limiterà la visualizzazione dell'output alla profondità 3. Naturalmente, la dimensione calcolata e visualizzata è sempre la profondità totale. Nonostante ciò, limitare la profondità di visualizzazione accelera drasticamente il calcolo.

Un'altra opzione utile è -h(parole su GNU e BSD ma, ancora una volta, non solo su POSIX du) per output "leggibili dall'uomo" (cioè usando KiB, MiB ecc .).

Puoi anche eseguire il comando seguente usando du:

~# du -Pshx /* 2>/dev/null

• L' -sopzione riepiloga e visualizza il totale per ciascun argomento.
• h stampa Mio, Gio, ecc.
• x = resta in un filesystem (molto utile).
• P = non seguire i collegamenti simbolici (che potrebbero causare il conteggio dei file due volte, ad esempio).

Fai attenzione, la /rootdirectory non verrà mostrata, devi correre ~# du -Pshx /root 2>/dev/nullper ottenerla (una volta ho faticato molto a non sottolineare che la mia /rootdirectory era piena).

Modifica: opzione corretta -P

Trovare i file più grandi sul filesystem richiederà sempre molto tempo. Per definizione devi attraversare l'intero filesystem alla ricerca di file di grandi dimensioni. L'unica soluzione è probabilmente quella di eseguire un processo cron su tutti i sistemi per avere il file pronto in anticipo.

Un'altra cosa, l'opzione x di du è utile per impedire a du di seguire i punti di mount in altri filesystem. Vale a dire:

du -x [path]

Il comando completo che di solito eseguo è:

sudo du -xm / | sort -rn > usage.txt

Il -mmezzo restituisce risultati in megabyte e sort -rnordina prima il numero più grande dei risultati. È quindi possibile aprire use.txt in un editor e le cartelle più grandi (che iniziano con /) saranno in alto.

Uso sempre du -sm * | sort -n, che ti dà un elenco ordinato di quanto utilizzano le sottodirectory dell'attuale directory di lavoro, in mebibyte.

Puoi anche provare Konqueror, che ha una modalità di "visualizzazione delle dimensioni", che è simile a quella che fa WinDirStat su Windows: ti dà una rappresentazione virtuale di quali file / directory consumano gran parte del tuo spazio.

Aggiornamento: nelle versioni più recenti, è anche possibile utilizzare quelle du -sh * | sort -hche mostreranno dimensioni di file leggibili dall'uomo e ordinate per quelle. (i numeri saranno suffissi con K, M, G, ...)

Per le persone che cercano un'alternativa alla visualizzazione della dimensione del file Konqueror di KDE3 possono dare un'occhiata alla luce dei file, anche se non è altrettanto piacevole.

Lo uso per i 25 peggiori trasgressori al di sotto della directory corrente

# -S to not include subdir size, sorted and limited to top 25
du -S . | sort -nr | head -25

In un'azienda precedente avevamo un cron job che veniva eseguito durante la notte e identificato qualsiasi file di una certa dimensione, ad es

trova / -size + 10000k

Potresti voler essere più selettivo sulle directory che stai cercando e fare attenzione a qualsiasi unità montata in remoto che potrebbe andare offline.

Un'opzione sarebbe quella di eseguire il comando du / sort come cron job e di inviarlo a un file, quindi è già lì quando ne hai bisogno.

Per la riga di comando penso che il metodo du / sort sia il migliore. Se non sei su un server, dai un'occhiata a Baobab - Analizzatore dell'utilizzo del disco . Anche questo programma richiede del tempo per essere eseguito, ma puoi facilmente trovare la sottodirectory in profondità, in fondo dove si trovano tutti i vecchi ISO di Linux.

Io uso

du -ch --max-depth=2 .

e cambio la profondità massima in base alle mie esigenze. L'opzione "c" stampa i totali per le cartelle e l'opzione "h" stampa le dimensioni in K, M o G come appropriato. Come altri hanno già detto, scansiona ancora tutte le directory, ma limita l'output in un modo che trovo più facile trovare le directory di grandi dimensioni.

Vado al secondo posto xdiskusage. Ma aggiungerò nella nota che in realtà è un du frontend e può leggere il du output da un file. Quindi puoi eseguire du -ax /home > ~/home-dusul tuo server, scpil file indietro e quindi analizzarlo graficamente. O passalo attraverso ssh.

Prova a inserire l'output di du in un semplice script awk che controlla se la dimensione della directory è maggiore di qualche soglia, in tal caso la stampa. Non devi aspettare che l'intero albero venga attraversato prima di iniziare a ottenere informazioni (rispetto a molte altre risposte).

Ad esempio, di seguito vengono visualizzate tutte le directory che consumano più di circa 500 MB.

du -kx / | awk '{ if ($1 > 500000) { print $0} }'

Per rendere un po 'più riutilizzabile quanto sopra, puoi definire una funzione nel tuo .bashrc (o potresti trasformarla in uno script autonomo).

dubig() {
    [ -z "$1" ] && echo "usage: dubig sizethreshMB [dir]" && return
    du -kx $2 | awk '{ if ($1 > '$1'*1024) { print $0} }'
}

Quindi dubig 200 ~/cerca nella directory home (senza seguire i symlink dal dispositivo) le directory che usano più di 200 MB.

Mi piace il buon vecchio xdiskusage come alternativa grafica a du (1).

Preferisco usare quanto segue per ottenere una panoramica e approfondire da lì ...

cd /folder_to_check
du -shx */

Ciò visualizzerà risultati con output leggibili dall'uomo come GB, MB. Impedirà inoltre di attraversare file system remoti. L' -sopzione mostra solo il riepilogo di ogni cartella trovata, quindi puoi approfondire ulteriormente se sei interessato a maggiori dettagli di una cartella. Tieni presente che questa soluzione mostrerà solo le cartelle, quindi vorrai omettere l'asterisco / after se vuoi anche i file.

Non menzionato qui, ma dovresti anche controllare lsof in caso di file cancellati / sospesi. Ho avuto un file tmp cancellato da 5,9 GB da un cronjob di fuga.

https://serverfault.com/questions/207100/how-can-i-find-phantom-storage-usage Mi ha aiutato a trovare il proprietario del processo di detto file (cron) e quindi sono stato in grado di andare /proc/{cron id}/fd/{file handle #}meno nel file in domanda per iniziare l'inizio della fuga, risolverlo, quindi echo ""> file per liberare spazio e lasciare che cron si chiuda con grazia.

Dal terminale, è possibile ottenere una rappresentazione visiva dell'utilizzo del disco con dutree

È molto veloce e leggero perché è implementato in Rust

$ dutree -h
Usage: dutree [options] <path> [<path>..]

Options:
    -d, --depth [DEPTH] show directories up to depth N (def 1)
    -a, --aggr [N[KMG]] aggregate smaller than N B/KiB/MiB/GiB (def 1M)
    -s, --summary       equivalent to -da, or -d1 -a1M
    -u, --usage         report real disk usage instead of file size
    -b, --bytes         print sizes in bytes
    -f, --files-only    skip directories for a fast local overview
    -x, --exclude NAME  exclude matching files or directories
    -H, --no-hidden     exclude hidden files
    -A, --ascii         ASCII characters only, no colors
    -h, --help          show help
    -v, --version       print version number

Vedi tutti i dettagli di utilizzo nel sito web

Per la riga di comando du (e le sue opzioni) sembra essere il modo migliore. DiskHog sembra che utilizzi anche le informazioni du / df da un lavoro cron, quindi il suggerimento di Peter è probabilmente la migliore combinazione di semplice ed efficace.

( FileLight e KDirStat sono ideali per la GUI.)

È possibile utilizzare strumenti standard come finde sortper analizzare l'utilizzo dello spazio su disco.

Elenca le directory ordinate per dimensione:

find / -mount -type d -exec du -s "{}" \; | sort -n

Elenca i file ordinati per dimensione:

find / -mount -printf "%k\t%p\n" | sort -n

Forse vale la pena notare che mc(Midnight Commander, un classico gestore di file in modalità testo) per impostazione predefinita mostra solo le dimensioni degli inode di directory (di solito 4096) ma con CtrlSpaceo con il menu Strumenti puoi vedere lo spazio occupato dalla directory selezionata in un leggibile umano formato (ad esempio, alcuni come 103151M).

Ad esempio, l'immagine seguente mostra la dimensione completa delle distribuzioni TeX Live alla vaniglia del 2018 e del 2017, mentre le versioni del 2015 e del 2016 mostrano solo le dimensioni dell'inode (ma hanno quasi 5 Gb ciascuna).

Cioè, CtrlSpacedeve essere fatto uno per uno, solo per il livello di directory attuale, ma è così veloce e utile quando si naviga con mcquello che forse non sarà necessario ncdu(che in effetti, solo per questo scopo è meglio). In caso contrario, è possibile anche eseguire ncduda mc. senza uscire mco avviare un altro terminale.

All'inizio controllo le dimensioni delle directory, in questo modo:

du -sh /var/cache/*/

Se sai che i file di grandi dimensioni sono stati aggiunti negli ultimi giorni (diciamo, 3), puoi usare un comando find insieme a " ls -ltra" per scoprire quei file aggiunti di recente:

find /some/dir -type f -mtime -3 -exec ls -lart {} \;

Questo ti darà solo i file (" -type f"), non le directory; solo i file con tempo di modifica negli ultimi 3 giorni (" -mtime -3") ed eseguire " ls -lart" su ogni file trovato (" -exec" parte).

Per comprendere l'utilizzo sproporzionato dello spazio su disco è spesso utile iniziare dalla directory principale e passare attraverso alcuni dei suoi figli maggiori.

Possiamo farlo entro

• salvando l'output di du in un file
• sfogliando il risultato in modo iterativo

Questo è:

# sum up the size of all files and directories under the root filesystem
du -a -h -x / > disk_usage.txt
# display the size of root items
grep $'\t/[^/]*$' disk_usage.txt

ora diciamo che / usr sembrano troppo grandi

# display the size of /usr items
grep $'\t/usr/[^/]*$' disk_usage.txt

ora se / usr / local è sospettosamente grande

# display the size /usr/local items
grep $'\t/usr/local/[^/]*$' disk_usage.txt

e così via...

Ho usato questo comando per trovare file di dimensioni superiori a 100 Mb:

find / -size +100M -exec ls -l {} \;

Ho avuto successo nel rintracciare i peggiori trasgressori che eseguono il piping dudell'output in forma leggibile dall'uomo egrepe la corrispondenza con un'espressione regolare.

Per esempio:

du -h | egrep "[0-9]+G.*|[5-9][0-9][0-9]M.*"

che dovrebbe restituirti tutto 500 o più mega.

Se si desidera la velocità, è possibile abilitare le quote sui filesystem che si desidera monitorare (non è necessario impostare quote per nessun utente) e utilizzare uno script che utilizza il comando quota per elencare lo spazio su disco utilizzato da ciascun utente. Per esempio:

quota -v $user | grep $filesystem | awk '{ print $2 }'

ti darebbe l'utilizzo del disco in blocchi per il particolare utente sul particolare filesystem. In questo modo dovresti essere in grado di controllare gli utilizzi in pochi secondi.

Per abilitare le quote dovrai aggiungere usrquota alle opzioni del filesystem nel tuo file / etc / fstab e quindi probabilmente riavviare in modo da poter eseguire quotacheck su un filesystem inattivo prima di chiamare quotaon.

Ecco una piccola app che utilizza il campionamento profondo per trovare i tumori in qualsiasi disco o directory. Cammina due volte l'albero della directory, una volta per misurarlo, e la seconda volta per stampare i percorsi su 20 byte "casuali" nella directory.

void walk(string sDir, int iPass, int64& n, int64& n1, int64 step){
    foreach(string sSubDir in sDir){
        walk(sDir + "/" + sSubDir, iPass, n, n1, step);
    }
    foreach(string sFile in sDir){
        string sPath = sDir + "/" + sFile;
        int64 len = File.Size(sPath);
        if (iPass == 2){
            while(n1 <= n+len){
               print sPath;
               n1 += step;
            }
        }
        n += len;
    }
}

void dscan(){
    int64 n = 0, n1 = 0, step = 0;
    // pass 1, measure
    walk(".", 1, n, n1);
    print n;
    // pass 2, print
    step = n/20; n1 = step/2; n = 0;
    walk(".", 2, n, n1);
    print n;
}

L'output è simile al seguente per la mia directory dei file di programma:

 7,908,634,694
.\ArcSoft\PhotoStudio 2000\Samples\3.jpg
.\Common Files\Java\Update\Base Images\j2re1.4.2-b28\core1.zip
.\Common Files\Wise Installation Wizard\WISDED53B0BB67C4244AE6AD6FD3C28D1EF_7_0_2_7.MSI
.\Insightful\splus62\java\jre\lib\jaws.jar
.\Intel\Compiler\Fortran\9.1\em64t\bin\tselect.exe
.\Intel\Download\IntelFortranProCompiler91\Compiler\Itanium\Data1.cab
.\Intel\MKL\8.0.1\em64t\bin\mkl_lapack32.dll
.\Java\jre1.6.0\bin\client\classes.jsa
.\Microsoft SQL Server\90\Setup Bootstrap\sqlsval.dll
.\Microsoft Visual Studio\DF98\DOC\TAPI.CHM
.\Microsoft Visual Studio .NET 2003\CompactFrameworkSDK\v1.0.5000\Windows CE\sqlce20sql2ksp1.exe
.\Microsoft Visual Studio .NET 2003\SDK\v1.1\Tool Developers Guide\docs\Partition II Metadata.doc
.\Microsoft Visual Studio .NET 2003\Visual Studio .NET Enterprise Architect 2003 - English\Logs\VSMsiLog0A34.txt
.\Microsoft Visual Studio 8\Microsoft Visual Studio 2005 Professional Edition - ENU\Logs\VSMsiLog1A9E.txt
.\Microsoft Visual Studio 8\SmartDevices\SDK\CompactFramework\2.0\v2.0\WindowsCE\wce500\mipsiv\NETCFv2.wce5.mipsiv.cab
.\Microsoft Visual Studio 8\VC\ce\atlmfc\lib\armv4i\UafxcW.lib
.\Microsoft Visual Studio 8\VC\ce\Dll\mipsii\mfc80ud.pdb
.\Movie Maker\MUI\0409\moviemk.chm
.\TheCompany\TheProduct\docs\TheProduct User's Guide.pdf
.\VNI\CTT6.0\help\StatV1.pdf
7,908,634,694

Mi dice che la directory è 7.9gb, di cui

• ~ 15% va al compilatore Intel Fortran
• ~ 15% va a VS .NET 2003
• ~ 20% va a VS 8

È abbastanza semplice chiedere se uno di questi può essere scaricato.

Descrive anche i tipi di file che sono distribuiti nel file system, ma considerati insieme rappresentano un'opportunità per risparmiare spazio:

• Il 15% circa è destinato ai file .cab e .MSI
• ~ Il 10% circa si riferisce alla registrazione di file di testo

Mostra anche molte altre cose, di cui probabilmente potrei fare a meno, come "SmartDevices" e il supporto "ce" (~ 15%).

Richiede un tempo lineare, ma non deve essere fatto spesso.

Esempi di cose che ha trovato:

• copie di backup di DLL in molti repository di codice salvate, che non realmente bisogno di essere salvato
• una copia di backup del disco rigido di qualcuno sul server, in una directory oscura
• voluminosi file temporanei Internet
• documenti antichi e file di aiuto necessari per un lungo passato

Ho avuto un problema simile, ma le risposte in questa pagina non sono state sufficienti. Ho trovato il seguente comando per essere il più utile per l'elenco:

du -a / | sort -n -r | head -n 20

Il che mi mostrerebbe i 20 più grandi trasgressori. Tuttavia, anche se ho eseguito questo, non mi ha mostrato il vero problema, perché avevo già eliminato il file. Il problema era che era ancora in esecuzione un processo che faceva riferimento al file di registro eliminato ... quindi ho dovuto interrompere prima quel processo, quindi lo spazio su disco è risultato libero.

Puoi utilizzare DiskReport.net per generare un rapporto web online di tutti i tuoi dischi.

Con molte esecuzioni mostrerà il grafico cronologico di tutte le cartelle, facile da trovare ciò che è cresciuto

C'è un bel pezzo di freeware multipiattaforma chiamato JDiskReport che include una GUI per esplorare ciò che occupa tutto quello spazio.

Schermata di esempio:

Naturalmente, dovrai liberare un po 'di spazio manualmente prima di poterlo scaricare e installarlo o scaricarlo su un'altra unità (come una chiavetta USB).

(Copiato qui dalla risposta dello stesso autore su una domanda duplicata)