Estado

O tamanho do bloco usado como unidade st_blocksé sempre de 512 bytes em sistemas que usam o kernel Linux (que inclui todos os sistemas GNU/Linux, como o Ubuntu). É desse tamanho na maioria dos outros sistemas operacionais do tipo Unix também.

Como Stephen Kitt explica em sua resposta a Por que st_blocks sempre é relatado em blocos de 512 bytes? :

O tamanho de um bloco é específico da implementação. No Linux são sempre 512 bytes, por razões históricas; em particular, costumava ser o tamanho típico de um setor de disco .

^{(ênfase minha)}

stat(2) lista os membros de struct stat, que incluem:

blkcnt_t  st_blocks;      /* number of 512B blocks allocated */

O statcomando (veja stat(1) ) também usa um tamanho de bloco de 512 bytes. Por exemplo, conforme revelado por ls -l, no meu sistema /bin/nanotem 208480 bytes e a saída de stat /bin/nanoincludes Blocks: 408.

ls

ls -limprime tamanhos de arquivo em bytes por padrão, mas ls -sos imprime em blocos de 1024 bytes. Existem lsimplementações para alguns sistemas do tipo Unix que padronizam para blocos de 512 bytes, mas tanto GNU ls (que fornece /bin/lsno Ubuntu) quanto busybox ls(a outra lsimplementação no Ubuntu) são padronizados para blocos de 1024 bytes. Você não precisa passar -kpor esse comportamento, embora possa ser necessário em alguns outros sistemas.

Ao imprimir tamanhos de arquivo em blocos, o lscomando do Ubuntu é padronizado para blocos de 1024 bytes porque eles são mais convenientes. Você pode mudar isso com --block-sizese quiser. Na prática, acredito que as abordagens mais populares são:

• passando -lsem -spara obter um tamanho em bytes (que é efetivamente um tamanho de bloco de 1)
• passando -lou -scom -hpara imprimir tamanhos mais legíveis com etiquetas de unidade
• passando -se usando o padrão de 1024 bytes

Alguns utilitários GNU imprimem blocos de 512 bytes quando executados em modo de compatibilidade POSIX . dué um caso particularmente óbvio; compare a saída de du /bin/nanocom a de POSIXLY_CORRECT= du /bin/nano. GNU ls também se comporta dessa maneira quando -sé passado, mas a saída com -le não -s, assim como a saída com -h, não é afetada. (A saída sem opções também não é afetada, pois isso não imprime um tamanho.)

Além de suportar --block-size, o GNU ls também respeita algumas outras variáveis ​​de ambiente, principalmente BLOCK_SIZE. Ao contrário POSIXLY_CORRECT, isso afeta não só, ls -smas também ls -lsem -s. Se, por algum motivo, você BLOCK_SIZEdefiniu, mas não deseja usá-lo, e deseja ls -susar blocos de 1024 bytes, passar -kcom -so substituirá.

Existem outras maneiras de ajustar isso, e alguma sutileza está envolvida quando mais de uma maneira é usada simultaneamente. Para detalhes rápidos, veja os exemplos abaixo e ls(1) ( man ls). Para detalhes completos, leia o manual GNU coreutils (que também deve estar disponível localmente: run info coreutils), especialmente a seção 2.3 Block size .

lsexemplos

Aqui estão alguns exemplos para controlar o tamanho da unidade mostrado por ls.

ls -limprime tamanhos em bytes:

$ ls -l /bin/nano
-rwxr-xr-x 1 root root 208480 Feb 15  2017 /bin/nano

ls -simprime tamanhos em blocos de 1024 bytes:

$ ls -s /bin/nano
204 /bin/nano

Adicionando-h a qualquer um imprime em formato legível por humanos:

$ ls -lh /bin/nano
-rwxr-xr-x 1 root root 204K Feb 15  2017 /bin/nano
$ ls -sh /bin/nano
204K /bin/nano

Passar -le -sanexar o que quer -sque apareça por si só, em vez de afetar as colunas de tamanho produzidas por-l :

$ ls -ls /bin/nano
204 -rwxr-xr-x 1 root root 208480 Feb 15  2017 /bin/nano
$ ls -lsh /bin/nano
204K -rwxr-xr-x 1 root root 204K Feb 15  2017 /bin/nano

Adicionando -kos comandos mostrados acima com -sou -lnão altera a saída, porque o GNU ls já padroniza para blocos de 2014 bytes com -s, e-l mostra tamanhos em bytes e não é afetado por -k. No entanto, -ktem efeito em situações mais complicadas (veja abaixo).

Adicionando--block-size=size-in-bytes faz com que os tamanhos sejam impressos em blocos do tamanho especificado:

$ ls --block-size=256 -s /bin/nano
816 /bin/nano
$ ls --block-size=512 -s /bin/nano
408 /bin/nano
$ ls --block-size=1024 -s /bin/nano
204 /bin/nano

Ao contrário de algumas outras opções, a --block-sizeopção tem esse efeito mesmo na coluna de tamanho produzida por ls -lque normalmente seria mostrada em bytes:

$ ls --block-size=256 -l /bin/nano
-rwxr-xr-x 1 root root 815 Feb 15  2017 /bin/nano
$ ls --block-size=512 -l /bin/nano
-rwxr-xr-x 1 root root 408 Feb 15  2017 /bin/nano
$ ls --block-size=1024 -l /bin/nano
-rwxr-xr-x 1 root root 204 Feb 15  2017 /bin/nano
$ ls -l /bin/nano
-rwxr-xr-x 1 root root 208480 Feb 15  2017 /bin/nano

--block-sizenão é substituído por -k, mesmo que -kapareça depois dele:

$ ls -s --block-size=256 -k /bin/nano
816 /bin/nano
$ ls -s -k --block-size=256 /bin/nano
816 /bin/nano
$ ls -l --block-size=256 -k /bin/nano
-rwxr-xr-x 1 root root 815 Feb 15  2017 /bin/nano
$ ls -l -k --block-size=256 /bin/nano
-rwxr-xr-x 1 root root 815 Feb 15  2017 /bin/nano

(Meus exemplos usam potências de dois, mas o operando --block-sizenão precisa ser uma potência de dois. Além disso, -se -laparentemente usam regras de arredondamento diferentes.)

Definir a BLOCK_SIZEvariável de ambiente tem um efeito semelhante a passar --block-size:

$ BLOCK_SIZE=256 ls -s /bin/nano
816 /bin/nano
$ BLOCK_SIZE=512 ls -s /bin/nano
408 /bin/nano
$ BLOCK_SIZE=1024 ls -s /bin/nano
204 /bin/nano

$ BLOCK_SIZE=256 ls -l /bin/nano
-rwxr-xr-x 1 root root 815 Feb 15  2017 /bin/nano
$ BLOCK_SIZE=512 ls -l /bin/nano
-rwxr-xr-x 1 root root 408 Feb 15  2017 /bin/nano
$ BLOCK_SIZE=1024 ls -l /bin/nano
-rwxr-xr-x 1 root root 204 Feb 15  2017 /bin/nano

A diferença de efeito entre a --block-sizeopção e a BLOCK_SIZEvariável de ambiente é que a BLOCK_SIZEvariável de ambiente é mais frequentemente substituída por opções. -ksubstituições BLOCK_SIZE:

$ BLOCK_SIZE=256 ls -k -s /bin/nano
204 /bin/nano

Isso funciona com -s. Mas -knão substitui os BLOCK_SIZEtamanhos exibidos por -l, simplesmente porque (conforme detalhado acima) -knão afeta isso:

$ BLOCK_SIZE=256 ls -k -l /bin/nano
-rwxr-xr-x 1 root root 815 Feb 15  2017 /bin/nano
$ BLOCK_SIZE=256 ls -kls /bin/nano
204 -rwxr-xr-x 1 root root 815 Feb 15  2017 /bin/nano

--block-sizetambém sobrepõe BLOCK_SIZE. Como --block-sizeafeta tanto -se -l, ele substitui BLOCK_SIZEambos:

$ BLOCK_SIZE=256 ls --block-size=512 -s /bin/nano
408 /bin/nano
$ BLOCK_SIZE=256 ls --block-size=512 -l /bin/nano
-rwxr-xr-x 1 root root 408 Feb 15  2017 /bin/nano
$ BLOCK_SIZE=256 ls --block-size=512 -ls /bin/nano
408 -rwxr-xr-x 1 root root 408 Feb 15  2017 /bin/nano

Definir a POSIXLY_CORRECTvariável de ambiente, mesmo para a string vazia, faz ls -scom que sejam usados ​​blocos de 512 bytes. As opções -h, -ke --block-sizesubstituem esse efeito, produzindo seu comportamento especificado. Mas ao contrário de --block-sizee BLOCK_SIZE, ls -lainda imprime tamanhos em bytes.

$ POSIXLY_CORRECT= ls -s /bin/nano
408 /bin/nano
$ POSIXLY_CORRECT= ls -sh /bin/nano
204K /bin/nano
$ POSIXLY_CORRECT= ls -sk /bin/nano
204 /bin/nano
$ POSIXLY_CORRECT= ls --block-size=256 -s /bin/nano
816 /bin/nano
$ POSIXLY_CORRECT= ls -l /bin/nano
-rwxr-xr-x 1 root root 208480 Feb 15  2017 /bin/nano

BLOCK_SIZEtem precedência sobrePOSIXLY_CORRECT :

$ BLOCK_SIZE=256 POSIXLY_CORRECT= ls -s /bin/nano
816 /bin/nano

As opções que afetam o tamanho do bloco também têm precedência sobre POSIXLY_CORRECT, pois POSIXLY_CORRECTestá apenas alterando o tamanho do bloco padrão. Em particular, -ksubstitui POSIXLY_CORRECT:

$ POSIXLY_CORRECT= ls -s /bin/nano
408 /bin/nano
$ POSIXLY_CORRECT= ls -sk /bin/nano
204 /bin/nano

ls- outras opções

Não mostrei todas as combinações de opções relevantes e variáveis ​​de ambiente.

Além disso, existem mais duas variáveis ​​de ambiente relacionadas a como o GNU ls escolhe os tamanhos dos blocos:

• BLOCKSIZE(observe que não há sublinhado) se comporta como BLOCK_SIZEfor ls -s, mas não ls -l. Ele adia BLOCK_SIZEquando isso está presente.
• LS_BLOCK_SIZEcomporta-se como BLOCK_SIZEmas afeta apenas lsmas não due df. Se ambos LS_BLOCK_SIZEe BLOCK_SIZEestiverem definidos, LS_BLOCK_SIZEserá usado.

Essas variáveis ​​de ambiente, como as outras, têm precedência sobre POSIXLY_CORRECT.

Como mencionado acima, veja a seção 2.3 Tamanho do bloco no manual GNU coreutils para mais informações, incluindo detalhes sobre eles. Este manual, que você pode ler na linha de comando digitando info coreutils, é muito mais detalhado do que as manpages lse outros comandos fornecidos pelo coreutils.