Comment puis-je déterminer ce qui prend autant d'espace?
J'utilisais df -h pour imprimer l'utilisation du disque lisible par l'homme. Je voudrais comprendre ce qui prend autant de place. Par exemple, existe-t-il un moyen de diriger cette commande afin qu'elle imprime des fichiers dont la taille est supérieure à 1 Go? D'autres idées?
Merci
J'utilise beaucoup celui-ci.
du -kscx *
L'exécution peut prendre un certain temps, mais elle vous indiquera où l'espace disque est utilisé.
Vous voudrez peut-être essayer l'utilitaire ncdu disponible sur: http://dev.yorhel.nl/ncd
Il additionnera rapidement le contenu d'un système de fichiers ou d'une arborescence de répertoires et imprimera les résultats, triés par taille. C'est une très bonne façon d'explorer de manière interactive et de voir ce qui consomme de l'espace disque.
De plus, il peut être plus rapide que certaines combinaisons du.
La sortie typique ressemble à:
ncdu 1.7 ~ Use the arrow keys to navigate, press ? for help
--- /data ----------------------------------------------------------------------------------------------------------
163.3GiB [##########] /docimages
84.4GiB [##### ] /data
82.0GiB [##### ] /sldata
56.2GiB [### ] /prt
40.1GiB [## ] /slisam
30.8GiB [# ] /isam
18.3GiB [# ] /mail
10.2GiB [ ] /export
3.9GiB [ ] /edi
1.7GiB [ ] /io
1.2GiB [ ] /dmt
896.7MiB [ ] /src
821.5MiB [ ] /upload
691.1MiB [ ] /client
686.8MiB [ ] /cocoon
542.5MiB [ ] /hist
358.1MiB [ ] /savsrc
228.9MiB [ ] /help
108.1MiB [ ] /savbin
101.2MiB [ ] /dm
40.7MiB [ ] /download
Vous pouvez utiliser la commande find. Exemple:
find /home/ -size +1073700000c -print
J'utilise moi-même
du -c --max-depth = 4/dir | trier -n
cela renvoie la quantité d'espace utilisée par un répertoire et ses sous-répertoires jusqu'à 4 profonds, sort -n mettra le dernier plus grand.
Les nouvelles versions de sort peuvent gérer des tailles "lisibles par l'homme", donc on peut utiliser beaucoup plus de lecture
du -hc --max-depth=4 /dir | sort -h
Recherche récursivement de gros fichiers dans un répertoire
Comme j’ai dû déterminer ce qui prend autant de place? beaucoup de temps, j’ai écrit ce petit script afin de chercher une grosse occupation sur un périphérique spécifique (sans argument, cela parcourra le répertoire actuel, en recherchant > 256 Mo entrées de répertoire):
#!/bin/bash
humansize() {
local _c=$1 _i=0 _a=(b K M G T P)
while [ ${#_c} -gt 3 ] ;do
((_i++))
_c=$((_c>>10))
done
_c=$(( ( $1*1000 ) >> ( 10*_i ) ))
printf ${2+-v} $2 "%.2f%s" ${_c:0:${#_c}-3}.${_c:${#_c}-3} ${_a[_i]}
}
export device=$(stat -c %d "${1:-.}")
export minsize=${2:-$((256*1024**2))}
rdu() {
local _dir="$1" _spc="$2" _crt _siz _str
while read _crt;do
if [ $(stat -c %d "$_crt") -eq $device ];then
_siz=($(du -xbs "$_crt"))
if [ $_siz -gt $minsize ];then
humansize $_siz _str
printf "%s%12s%14s_%s\n" "$_spc" "$_str" \\ "${_crt##*/}"
[ $d "$_crt" ] && rdu "$_crt" " $_spc"
fi
fi
done < <(
find "$_dir" -mindepth 1 -maxdepth 1 -print
)
}
rdu "${1:-.}"
Exemple d'utilisation:
./rdu.sh /usr 100000000
1.53G \_lib
143.52M \_i386-linux-gnu
348.16M \_x86_64-linux-gnu
107.80M \_jvm
100.20M \_Java-6-openjdk-AMD64
100.17M \_jre
99.65M \_lib
306.63M \_libreoffice
271.75M \_program
107.98M \_chromium
99.57M \_lib32
452.47M \_bin
2.50G \_share
139.63M \_texlive
129.74M \_texmf-dist
478.36M \_locale
124.49M \_icons
878.09M \_doc
364.02M \_texlive-latex-extra-doc
359.36M \_latex
Petit chèque:
du -bs /usr/share/texlive/texmf-dist
136045774 /usr/share/texlive/texmf-dist
echo 136045774/1024^2 | bc -l
129.74336051940917968750
Remarque: en utilisant -b Au lieu de -k, Dites à du de résumer uniquement les octets utilisés, mais pas l'espace réservé effectif (par bloc de 512 octets). Pour travailler sur la taille des blocs, vous devez changer la ligne du -xbs ... Par du -xks, Supprimer b dans _a=(K M G T P) et diviser la taille des arguments par 1024.
... Il existe une version modifiée (je garderai pour moi) en utilisant les blocs tailles par défaut, mais en acceptant -b Comme premier argument pour le calcul des octets:
Edit: Nouvelle version
Après quelques travaux, il y a beaucoup de nouvelles versions plus rapides et avec une sortie triée par ordre décroissant de taille:
#!/bin/bash
if [ "$1" == "-b" ] ;then
shift
export units=(b K M G T P)
export duargs="-xbs"
export minsize=${2:-$((256*1024**2))}
else
export units=(K M G T P)
export duargs="-xks"
export minsize=${2:-$((256*1024))}
fi
humansize() {
local _c=$1 _i=0
while [ ${#_c} -gt 3 ] ;do
((_i++))
_c=$((_c>>10))
done
_c=$(( ( $1*1000 ) >> ( 10*_i ) ))
printf ${2+-v} $2 "%.2f%s" ${_c:0:${#_c}-3}.${_c:${#_c}-3} ${units[_i]}
}
export device=$(stat -c %d "${1:-.}")
rdu() {
local _dir="$1" _spc="$2" _crt _siz _str
while read _siz _crt;do
if [ $_siz -gt $minsize ];then
humansize $_siz _str
printf "%s%12s%14s_%s\n" "$_spc" "$_str" \\ "${_crt##*/}"
[ -d "$_crt" ] &&
[ $(stat -c %d "$_crt") -eq $device ] &&
rdu "$_crt" " $_spc"
fi
done < <(
find "$_dir" -mindepth 1 -maxdepth 1 -xdev \
\( -type f -o -type d \) -printf "%D;%p\n" |
sed -ne "s/^${device};//p" |
tr \\n \\0 |
xargs -0 du $duargs |
sort -nr
)
}
rdu "${1:-.}"
Avec des tailles lisibles par l'homme:
du -hscx *
Pour afficher les 20 répertoires les plus volumineux du dossier en cours, utilisez la ligne unique suivante:
du -ah . | sort -rh | head -20
ou:
du -a . | sort -rn | head -20
Pour les 20 plus gros fichiers du répertoire actuel (récursivement):
ls -1Rs | sed -e "s/^ *//" | grep "^[0-9]" | sort -nr | head -n20
ou avec des tailles lisibles par l'homme:
ls -1Rhs | sed -e "s/^ *//" | grep "^[0-9]" | sort -hr | head -n20
La deuxième commande pour fonctionner correctement sur OSX/BSD (comme
sortn'a pas-h), vous devez installersortà partir decoreutils. Ajoutez ensuite le dossier bin à votrePATH.
Ces alias sont donc utiles à avoir dans vos fichiers rc (à chaque fois que vous en avez besoin):
alias big='du -ah . | sort -rh | head -20'
alias big-files='ls -1Rhs | sed -e "s/^ *//" | grep "^[0-9]" | sort -hr | head -n20'