Tutorial do Debian 13 / Diagnosticar falta de espaço, inodes, arquivos excluídos abertos e tmpfs

Quando você não consegue escrever arquivos no Debian 13, primeiro deve verificar separadamente a capacidade de blocos e inodes do caminho em questão. Se o espaço usado não diminuir e o espaço livre não aumentar após excluir arquivos, verifique por arquivos deletados ainda abertos e, se for um problema no /tmp, verifique o limite do tmpfs, que é separado do disco raiz. Neste tutorial, comparamos três causas em um pequeno espaço de prática dedicado sem deletar arquivos de serviços em produção.

Comece pelo caminho onde a escrita falhou

Um inode é um objeto no sistema de arquivos que gerencia informações como tipo de arquivo, permissões, propriedade e localização dos dados. Mesmo arquivos vazios usam inodes, então você pode não conseguir criar novos arquivos mesmo que haja muito espaço em nível de bytes. Por outro lado, alguns arquivos grandes podem esgotar os blocos.

Adapte os caminhos dos comandos a seguir ao local onde a escrita realmente falhou. É importante não julgar /var/tmp e /tmp juntos como um problema do disco raiz.

findmnt --target /var/tmp -o TARGET,SOURCE,FSTYPE,OPTIONS
df -hT /var/tmp
df -i /var/tmp
sudo du -x -h --max-depth=1 /var | sort -h

findmnt mostra o ponto de montagem real que contém o caminho, e df mostra o espaço daquele sistema de arquivos. df -i verifica a disponibilidade de inodes. du soma os arquivos vinculados sob a árvore de diretórios acessível, e -x impede cruzar para outros sistemas de arquivos. Se ocorrerem erros de permissão, o total estará incompleto. Não esconda esses erros e depois trate o total como preciso. Executar du em uma árvore grande leva tempo e realiza I/O, então restrinja o alcance a partir do caminho problemático.

Resultados da observação Causas para verificar primeiro Determinação de ação
Quase não há espaço em bloco restante, mas inodes permanecem Arquivos grandes, logs, aumento de dados reais Verifique o serviço proprietário e a política de retenção, e planeje mover, rotacionar ou expandir.
Blocos permanecem, mas não há inodes Um número muito grande de arquivos pequenos, aumento de cache ou fila Identifique o diretório problemático e a causa da criação, e então use a função de limpeza do aplicativo.
df mostra uso alto, mas o total de du é pequeno Arquivos abertos deletados, arquivos ocultos por montagens, diferenças de permissão ou escopo de agregação Compare com o mesmo sistema de arquivos e permissões, então investigue o processo e a estrutura de montagem.
/ tem espaço disponível, mas escrever em /tmp falha Tamanho e limites de inode de um tmpfs separado ou status da memória Verifique df e as opções de montagem de /tmp junto com free.

Permission denied (permissão negada), Read-only file system (sistema de arquivos somente leitura) e Disk quota exceeded (cota excedida) indicam causas diferentes da falta de espaço. Mesmo que haja espaço disponível, a falha pode ocorrer devido à propriedade, listas de controle de acesso (ACLs, Access Control Lists), montagens somente leitura ou cotas. Por causa do espaço reservado e dos metadados no ext4, df e o tamanho do conteúdo do arquivo não precisam corresponder exatamente. Discrepâncias de espaço sozinhas não determinam corrupção.

Compare o esgotamento de blocos e inodes em um tmpfs de 4 MiB

O laboratório utiliza Python 3, e2fsprogs (mkfs.ext4 e e2fsck), util-linux (mount, findmnt e losetup) e ferramentas padrão de arquivos GNU. Verifique command -v python3 mkfs.ext4 e2fsck mount findmnt losetup truncate df du primeiro. Se algo estiver faltando, inspecione as alterações do pacote antes de instalar o pacote Debian necessário. Execute a configuração em uma sessão Bash dedicada: uma falha inesperada sob set -euo pipefail pode encerrar aquele shell. Reconecte se necessário, inspecione a montagem do laboratório e os arquivos, depois use a limpeza direcionada em vez de recriar os recursos sobre eles.

É necessária uma VM de prática separada do Debian 13, um usuário comum que possa usar sudo e Python 3. O exemplo abaixo cria um tmpfs dedicado de até 4MiB e 32 inodes sem ocupar o /tmp. O tmpfs usa memória virtual, e se o swap estiver habilitado, algumas páginas podem ir para o swap. Não assuma que ele está armazenado apenas na RAM física, e os conteúdos são perdidos quando desmontados.

O próximo bloco deve ser executado no mesmo terminal Bash. Se o caminho já existir, pare e examine seu conteúdo e uso; não o exclua para contornar essa verificação. Na VM do teste original, o UID e GID do usuário comum eram ambos 1000, mas os comandos usam os valores da conta atual.

set -euo pipefail
tm=/mnt/lf-space24-tmpfs
if test -e "$tm"; then
    echo "Path already exists: $tm" >&2
    exit 1
fi
sudo mkdir "$tm"
sudo mount -t tmpfs -o "size=4M,nr_inodes=32,uid=$(id -u),gid=$(id -g),mode=0700,nosuid,nodev" tmpfs "$tm"
findmnt --mountpoint "$tm"

Após verificar que o resultado da montagem é tmpfs e que o tamanho corresponde a 4MiB, execute o seguinte exemplo completo como um usuário comum. As tentativas de escrita são limitadas a um máximo de 8MiB, e o número de arquivos vazios é limitado a um máximo de 40. Apenas o erro esperado ENOSPC (No space left on device, sem espaço disponível no dispositivo) é tratado, e outros erros irão interromper o processo.

python3 - <<'PY'
import errno, pathlib, subprocess
p=pathlib.Path('/mnt/lf-space24-tmpfs')
try:
    with (p/'fill.bin').open('xb') as f:
        for i in range(8):
            f.write(b'x' * 1048576)
            f.flush()
except OSError as e:
    if e.errno != errno.ENOSPC: raise
    print('BLOCK_LIMIT_ENOSPC', flush=True)
else:
    raise RuntimeError('Expected bounded block exhaustion')
subprocess.run(['df','-hT',str(p)],check=True)
subprocess.run(['df','-i',str(p)],check=True)
(p/'fill.bin').unlink()
created=[]
try:
    for i in range(40):
        f=p/f'empty-{i}'
        f.touch(exist_ok=False)
        created.append(f)
except OSError as e:
    if e.errno != errno.ENOSPC: raise
    print('INODE_LIMIT_ENOSPC',len(created),flush=True)
else:
    raise RuntimeError('Expected bounded inode exhaustion')
subprocess.run(['df','-hT',str(p)],check=True)
subprocess.run(['df','-i',str(p)],check=True)
for f in created: f.unlink()
PY

O teste original, com kernel 6.12.107 e Python 3.13.5, produziu os resultados abaixo, correspondentes ao esgotamento de dois recursos diferentes. Os 32 inodes incluem o diretório de nível superior da montagem, então a falha ocorreu após 31 arquivos vazios serem criados.

Experimento Uso de blocos Uso de inodes
Escrevendo em fill.bin 4,0MiB / 4,0MiB, livre 0 2 / 32, livre 30
Após excluir fill.bin e criar arquivos vazios Usado 0, Livre 4,0MiB 32 / 32, Livre 0

O arquivo criado será deletado quando o exemplo terminar. Se ele foi interrompido por outro erro no meio, primeiro verifique o destino de montagem e os arquivos dentro. Este tmpfs é apenas para dados de prática descartáveis, então você pode desmontá-lo com o seguinte comando fora do diretório de trabalho. Se você receber um erro dizendo que está em uso, mova o diretório atual de cada shell relevante para fora deste caminho e feche quaisquer manipuladores de arquivos mantidos pelos processos do laboratório antes de tentar novamente.

cd "$HOME"
sudo umount /mnt/lf-space24-tmpfs
sudo rmdir /mnt/lf-space24-tmpfs

Observe o espaço retido por um arquivo excluído ainda aberto

Excluir um arquivo usando a operação unlink e fechar um arquivo aberto são coisas diferentes. Mesmo que o último nome em um diretório tenha desaparecido, se um processo ainda o tiver aberto, o espaço do arquivo pode ser mantido. Se você sempre excluir logs com rm, você poderia criar essa situação e perder os nomes que pretendia investigar.

A seguir, é uma prática para criar um ext4 dentro de um novo arquivo regular de 64MiB. Isso não inicializa um dispositivo de disco real. Primeiro, verifique se há mais de 64MiB de espaço livre no sistema de arquivos raiz e um pouco de espaço extra de trabalho. Se o mesmo caminho já existir, pare e investigue seu uso. Execute todo o bloco de preparação abaixo no mesmo terminal Bash também.

set -euo pipefail
base=/var/lib/lf-space24
em=/mnt/lf-space24-ext4
df -hT /var/lib /mnt
for p in "$base" "$em"; do
    if test -e "$p"; then
        echo "Path already exists: $p" >&2
        exit 1
    fi
done
sudo install -d -m 700 "$base"
sudo mkdir "$em"
sudo truncate -s 64M "$base/space.img"
sudo mkfs.ext4 "$base/space.img"
sudo mount -o loop,nosuid,nodev "$base/space.img" "$em"
findmnt --mountpoint "$em"
sudo install -d -o "$(id -u)" -g "$(id -g)" "$em/work"

Arquivos criados com truncate são inicialmente arquivos esparsos, então o tamanho lógico de 64MiB não é imediatamente totalmente alocado fisicamente. Metadados do sistema de arquivos e gravações subsequentes usam espaço real. O alvo do mkfs deve ser o recém-criado space.img e não deve ser substituído por um nome de disco como /dev/sda.

O lost+found do ext4 pode não ser legível por usuários comuns, então sem alterar a propriedade de forma imprudente, apenas o diretório de trabalho separado é medido. O código a seguir abre e grava um arquivo de 8MiB, deleta seu nome e compara antes e depois de fechar o arquivo dentro do mesmo processo.

python3 - <<'PY'
import os,pathlib,subprocess
p=pathlib.Path('/mnt/lf-space24-ext4/work')
def used():
    return int(subprocess.check_output(['df','--output=used','-B1',str(p)],text=True).splitlines()[1])
def show(label):
    os.sync()
    print(label,flush=True)
    subprocess.run(['df','-B1',str(p)],check=True)
    subprocess.run(['du','-B1','-s',str(p)],check=True)
baseline=used()
f=(p/'held.bin').open('xb')
for i in range(8): f.write(b'x'*1048576)
f.flush();os.fsync(f.fileno())
show('BEFORE_UNLINK');before=used()
(p/'held.bin').unlink()
print('OPEN_FD',os.readlink(f'/proc/self/fd/{f.fileno()}'),flush=True)
show('UNLINKED_OPEN');held=used()
f.close()
show('AFTER_CLOSE');released=used()
if not (before >= baseline+8388608 and held == before and released < held):
    raise RuntimeError((baseline,before,held,released))
print('DELETED_OPEN_FILE_RELEASE_PASSED',baseline,before,held,released,flush=True)
PY
Tempo Bytes usados do df du: total de bytes do diretório work
Após escrever arquivo de 8MiB 8.436.736 8.389.632
Nome deletado, arquivo ainda aberto 8.436.736 1.024
Após fechar o arquivo 48.128 1.024

Os números acima são as medições reais dessa imagem prática e podem variar dependendo das opções de criação do sistema de arquivos e da versão. O resultado importante é que, após deletar o nome, apenas o du diminuiu enquanto o df permaneceu o mesmo, e após fechar, o uso do df também diminuiu. A saída de /proc/self/fd mostrou held.bin (deleted). os.sync apenas sincroniza as gravações antes da observação e não fecha arquivos abertos à força.

Em servidores de produção, verifique o recurso de reabertura de logs do processo que abriu o arquivo e do serviço. Se o lsof estiver instalado, você pode investigar arquivos abertos com uma contagem de links menor que 1 usando sudo lsof +L1, mas nos resultados, dispositivos, arquivos e processos devem ser cruzados juntos. Reiniciar afeta conexões e operações, então primeiro revise o método de rotação/reabertura de logs suportado pelo serviço. Não escreva arbitrariamente no descritor de arquivo /proc de outro processo nem encerre um processo diretamente.

Verifique a imagem ext4 apenas após desmontar

A prática acima não causou corrupção no ext4. Não há necessidade de executar o e2fsck apenas porque o espaço está cheio. O manual do Debian e2fsck alerta contra executá-lo em um sistema de arquivos montado e, embora algumas execuções somente leitura sejam possíveis, os resultados da verificação não são válidos enquanto o sistema de arquivos está montado.

Nesta prática, verificamos se nenhum processo mantém arquivos abertos dentro de work, liberamos a imagem e então executamos uma verificação somente leitura com -fn. -f força uma verificação completa e -n é o modo somente leitura que recusa alterações. O alvo é um único arquivo de imagem de prática.

cd "$HOME"
sudo umount /mnt/lf-space24-ext4
sudo losetup -j /var/lib/lf-space24/space.img
sudo e2fsck -fn /var/lib/lf-space24/space.img

O resultado do losetup -j deve estar vazio. Se houver conexões restantes, não exclua a imagem e verifique qual montagem ou processo está usando-a. Na prática normal, a verificação passo a passo por e2fsck é concluída e sai com o código 0. Se não for 0, preserve o código de saída e saída sem excluir o arquivo imediatamente. Verificar o sistema de arquivos raiz em produção é uma tarefa de recuperação separada que requer preparar um ambiente de boot de console, backup ou resgate e verificar novamente o UUID de destino enquanto a raiz estiver desmontada.

Após a verificação ser concluída normalmente, apenas a imagem de prática é excluída. Discos de dados existentes, LVM de aulas anteriores e /etc/fstab não são modificados.

sudo rm -- /var/lib/lf-space24/space.img
sudo rmdir /var/lib/lf-space24 /mnt/lf-space24-ext4
findmnt --target /tmp -o TARGET,SOURCE,FSTYPE,OPTIONS
df -hT / /tmp /var/tmp

Verifique o armazenamento e a retenção de arquivos temporários no Debian 13

De acordo com o aviso de alteração do /tmp no Debian 13, o /tmp padrão é tmpfs e o limite de tamanho padrão é metade da memória. Esse máximo não representa memória reservada desde o início: o consumo depende dos arquivos realmente criados. Configurações separadas de /tmp no fstab existente podem alterar o resultado, então primeiro verifique a montagem real.

findmnt --target /tmp -o TARGET,SOURCE,FSTYPE,OPTIONS
findmnt --target /var/tmp -o TARGET,SOURCE,FSTYPE,OPTIONS
systemctl cat tmp.mount
systemd-tmpfiles --cat-config | less
systemctl cat systemd-tmpfiles-clean.timer
systemctl list-timers systemd-tmpfiles-clean.timer --no-pager
free -h

No less, você pode pesquisar com /tmp.conf e sair com q. Como cat-config mostra várias configurações, verifique não apenas os padrões em /usr/lib/tmpfiles.d, mas também quaisquer entradas sobrescritas por arquivos com o mesmo nome em /etc/tmpfiles.d. Não execute systemd-tmpfiles --clean para fins de verificação. Este comando pode, na verdade, realizar exclusões.

Na VM de instalação nova do teste original, /tmp era um tmpfs com um máximo de cerca de 2 GiB, e /var/tmp estava incluído no ext4 raiz. As regras padrão aplicadas foram /tmp 10 dias, /var/tmp 30 dias, e o temporizador de limpeza foi definido para 15 minutos após a inicialização e depois em intervalos de um dia contados a partir da ativação anterior da tarefa de limpeza. Não há garantia de que os arquivos serão excluídos imediatamente apenas porque a data tenha chegado; os carimbos de data/hora dos arquivos, as regras de exclusão e o momento da execução do temporizador todos têm efeito.

Orientações sobre as alterações na limpeza de arquivos temporários no Debian também explicam as diferenças entre instalações novas e atualizações. Em sistemas atualizados do Debian 12 para o Debian 13, /etc/tmpfiles.d/tmp.conf pode ser criado para manter o comportamento anterior de retenção, portanto, você não deve assumir a mesma programação de exclusão de uma instalação nova. /var/tmp geralmente permanece após uma reinicialização, mas não é um local de armazenamento permanente.

Para arquivos temporários pequenos e de curta duração, use /tmp, e para trabalhos temporários maiores, escolha um caminho separado com espaço suficiente. Após garantir que o serviço siga a configuração TMPDIR, altere-a conforme necessário, e coloque os dados persistentes e backups em caminhos dedicados de estado/backups. Conforme as diretrizes do systemd para diretórios temporários , use métodos de criação seguros como mktemp em diretórios temporários compartilhados. Os limites do tmpfs e o comportamento de swap podem ser verificados na documentação tmpfs do kernel Linux , e a prioridade das regras de limpeza e a determinação de tempo podem ser encontradas na documentação tmpfiles.d do Debian .