Como posso determinar o que está ocupando tanto espaço? [duplicado]

Question

Eu estava usando df -h para imprimir o uso de disco legível por humanos. Eu gostaria de descobrir o que está ocupando muito espaço. Por exemplo, existe uma maneira de canalizar esse comando para que ele imprima arquivos maiores que 1 GB? Outras ideias?

Obrigado

    

Answer 1

Eu uso muito isso aqui.

du -kscx *

Pode demorar um pouco para ser executado, mas ele informará onde o espaço em disco está sendo usado.

    

Answer 2

Você pode experimentar o utilitário ncdu encontrado em: link

Ele resumirá rapidamente o conteúdo de um sistema de arquivos ou árvore de diretórios e imprimirá os resultados, classificados por tamanho. É uma ótima maneira de fazer uma pesquisa detalhada e ver o que está consumindo espaço em disco.

Além disso, pode ser mais rápido que algumas combinações de du .

A saída típica se parece com:

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

    

Answer 3

Você pode usar o comando find. Exemplo:

find /home/ -size [phone]c -print

    

Answer 4

Eu mesmo uso

du -c --max-depth=4 /dir | sort -n

isso retorna a quantidade de espaço usada por um diretório e seus subdiretórios até 4 deep, sort -n colocará o maior em último lugar.

Novas versões de sort podem lidar com tamanhos "legíveis por humanos", por isso é possível usar muito mais legível

du -hc --max-depth=4 /dir | sort -h

    

Answer 5

Com tamanhos legíveis por humanos:

du -hscx *

    

Answer 6

Busca recursivamente por arquivos grandes em um diretório

Como eu tenho que determinar o que está ocupando tanto espaço? muito tempo, eu escrevi este pequeno roteiro para procurar por uma grande ocupação em um dispositivo específico (sem argumento, isso vai navegue pelo diretório atual, procurando por entradas de diretório > 256Mb ):

#!/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:-.}"

Amostra de uso:

./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

Verificação pequena:

du -bs /usr/share/texlive/texmf-dist
136045774   /usr/share/texlive/texmf-dist
echo 136045774/1024^2 | bc -l
129.74336051940917968750

Nota: usando -b em vez de -k tell du para sumarizar somente bytes usados, mas não efetivo espaço reservado (por bloco de 512 bytes). Para trabalhar com tamanho de blocos, você precisa alterar a linha du -xbs ... por du -xks , suprimir b em _a=(K M G T P) e dividir o tamanho do argumento por 1024.

... Por padrão, há uma versão modificada (por enquanto manterei) usando blocos , mas aceitando -b como primeiro argumento para cálculo de bytes:

Editar: nova versão

Depois de algum trabalho, há uma versão mais recente mais rápida e com a saída classificada em ordem de tamanho decrescente:

#!/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:-.}"

    

Answer 7

Para exibir os maiores diretórios top-20 na pasta atual, use o seguinte one-liner:

du -ah . | sort -rh | head -20

ou:

du -a . | sort -rn | head -20

Para os 20 maiores arquivos no diretório atual (recursivamente):

ls -1Rs | sed -e "s/^ *//" | grep "^[0-9]" | sort -nr | head -n20

ou com tamanhos legíveis por humanos:

ls -1Rhs | sed -e "s/^ *//" | grep "^[0-9]" | sort -hr | head -n20

The second command to work on OSX/BSD properly (as sort doesn't have -h), you need to install sort from coreutils. Then add the bin folder to your PATH.

Portanto, esses aliases são úteis em seus arquivos rc (sempre que você precisar):

alias big='du -ah . | sort -rh | head -20'
alias big-files='ls -1Rhs | sed -e "s/^ *//" | grep "^[0-9]" | sort -hr | head -n20'