# Inode em 100% com disco livre: sessões PHP acumuladas

Como achar o save_path efetivo de cada conta, entender por que o menor gc_maxlifetime apaga as sessões dos vizinhos e limpar só o que já expirou.

> arquivos `sess_*` do handler files consomem um inode cada e quase nenhum byte, então o filesystem pode estourar inode com `df -h` mostrando espaço livre. O diagnóstico começa em `df -i`, passa pelo `session.save_path` efetivo do vhost e termina com `find -name 'sess_*' -mtime`.

João Rizzon · 2026-10-23 · Servidores

---

## O sintoma: gravação falha com disco sobrando

O quadro é específico. O site começa a devolver erro ao salvar upload, o PHP não cria sessão nova (o usuário loga e volta para a tela de login), o cron grava log vazio, e `df -h` mostra espaço livre. Quem olha só o percentual de disco conclui que não é cota e vai procurar bug na aplicação.

O limite estourado é outro: inode. Cada arquivo, diretório, link simbólico e arquivo de sessão consome uma entrada na tabela de inodes do filesystem (ou da cota do usuário, quando o limite é por conta). Um arquivo `sess_` do handler `files` costuma ter poucos bytes. Mil sessões ocupam quase nada de disco e exatamente mil inodes.

Por isso o acúmulo de `sess_*` é a causa mais silenciosa de "disco cheio" em hospedagem compartilhada: o número que estoura não aparece no gráfico de uso de disco.

```bash
# inodes do filesystem
df -i /home

# inodes por conta, quando a cota do usuário limita inode
repquota -s /home | head -30
```

Se `IUse%` está em 100% e `Use%` em 40%, pare de investigar a aplicação e vá para o `save_path`.

## Onde o PHP realmente grava a sessão nesta conta

Não confie no `php.ini` global. Em servidor cPanel com múltiplas versões de PHP, handlers distintos e CloudLinux, o `session.save_path` efetivo é resultado de uma pilha de sobreposições. O que vale é o valor que o processo que serve aquele vhost enxerga.

### Pergunte ao binário da versão de PHP que a conta usa

```bash
# versão em uso pela conta (ea-php81, ea-php83, alt-php74 etc.)
/opt/cpanel/ea-php81/root/usr/bin/php -i | grep -E 'session.save_path|session.gc_maxlifetime|Loaded Configuration'
```

Isso mostra o INI carregado e os dois valores que interessam. Mas ainda é o CLI, não necessariamente o SAPI web.

### Procure sobreposição por conta em .user.ini, php.ini local e código

```bash
# .user.ini (PHP-FPM e CGI/FastCGI respeitam)
find /home/USUARIO/public_html -maxdepth 2 -name '.user.ini' -exec grep -H session {} \;

# php.ini local em DocumentRoot (handlers CGI/suPHP antigos)
find /home/USUARIO -maxdepth 3 -name 'php.ini' 2>/dev/null

# ini_set no código, que vence tudo em runtime
grep -rn "session.save_path\|session_save_path" /home/USUARIO/public_html --include='*.php' | head
```

### Se o handler é PHP-FPM, o pool pode vencer tudo

O pool do cPanel por domínio define diretivas `php_admin_value`. Diretiva marcada como `php_admin_value` não pode ser sobrescrita por `.user.ini` nem por `ini_set`, o que muda o diagnóstico inteiro.

```bash
grep -R 'session' /opt/cpanel/ea-php81/root/etc/php-fpm.d/ | grep -v '^#'
```

### Confirme o valor real pelo SAPI web, não pelo CLI

A prova final é um arquivo temporário no vhost:

```php
<?php // apenas para diagnóstico, apague depois
var_dump(ini_get('session.save_path'), ini_get('session.gc_maxlifetime'),
         ini_get('session.gc_probability'), ini_get('session.gc_divisor'));
```

Acesse por HTTP, anote, remova o arquivo. É o único caminho que reflete handler, pool e `.user.ini` juntos.

## O GC do handler files roda por sorteio, e por isso pode nunca rodar

Aqui está o ponto que mais gera conclusão errada em servidor compartilhado, e vale fixar com cuidado porque o comportamento é pouco intuitivo. Tudo abaixo é verificável no seu próprio servidor com os comandos das seções anteriores.

Com `session.save_handler = files`, não existe daemon de limpeza. O GC roda **por sorteio, dentro de uma requisição qualquer que inicia sessão**. A chance de rodar é `session.gc_probability / session.gc_divisor`. Com `1/1000`, uma requisição em mil dispara a varredura.

Quando dispara, o PHP varre o `session.save_path` **daquele processo** e remove arquivos cuja última modificação é mais antiga que o `session.gc_maxlifetime` **daquele processo**. A varredura não sabe de quem é cada arquivo: ela aplica o critério de idade a tudo que encontra no diretório.

Duas consequências diretas:

- **Quem tem o menor `gc_maxlifetime` apaga mais cedo.** Uma conta configurada com 300 segundos, ao sortear o GC, remove arquivos com mais de 5 minutos de idade.
- **Se o `save_path` é compartilhado entre contas, essa varredura alcança as sessões das outras.** O vhost com 300 segundos derruba sessões do vhost configurado com 86400. O sintoma no site vizinho é logout aleatório, não inode.

E o espelho disso é o caso que gera o estouro: se nenhum processo que escreve naquele diretório tem GC ativo, ou se `gc_probability` está em 0, ninguém nunca varre. Os arquivos ficam. Esse cenário aparece quando o INI em uso zera a probabilidade e delega a limpeza a uma rotina externa. Confira os dois lados antes de concluir: o valor efetivo, com `php -i | grep -E 'gc_probability|gc_divisor'` no binário da versão certa (e pelo SAPI web, como no passo 4), e a existência da rotina, com `ls /etc/cron.d/ /etc/cron.daily/` e `crontab -l -u root` procurando referência a sessão. Se o `save_path` em uso não está entre os caminhos cobertos por essa rotina, o acúmulo não tem fim.

| Configuração do vhost | Efeito no diretório compartilhado |
|---|---||
| `gc_maxlifetime` baixo, GC ativo | varre cedo, apaga sessão viva de vizinho com lifetime alto |
| `gc_maxlifetime` alto, GC ativo | só remove o que já é bem antigo |
| `gc_probability = 0` | nunca varre, só consome inode |
| `save_path` isolado por conta | cada conta só afeta a si mesma |

## Três números para anotar antes de apagar qualquer coisa

Apagar sem medir impede saber se o problema voltou. Registre três números antes da limpeza.

```bash
# 1. inode do filesystem
df -i /home

# 2. quantidade de arquivos de sessão no save_path
ls -U /var/cpanel/php/sessions/ea-php81 | wc -l

# 3. os diretórios com mais arquivos abaixo de /home
find /home -xdev -type f -printf '%h\n' 2>/dev/null \
  | sort | uniq -c | sort -rn | head -20
```

O `ls -U` evita ordenação, que em diretório com centenas de milhares de entradas custa tempo e memória. A travessia completa do passo 3 percorre todos os arquivos de `/home`, então ela é cara em disco rotacional e em filesystem com muitos milhões de entradas: rode em janela de baixa carga, ou limite a varredura a um home por vez trocando `/home` por `/home/USUARIO`. Em diretórios realmente grandes, prefira contar sem montar a lista:

```bash
find /var/cpanel/php/sessions/ea-php81 -maxdepth 1 -type f -name 'sess_*' -printf '.' | wc -c
```

Para dimensionar o problema por faixa de idade antes de escolher o corte (os números abaixo são **exemplo ilustrativo**, não medição):

```bash
cd /var/cpanel/php/sessions/ea-php81
for d in 1 7 30 90; do
  printf '%s dias+: ' "$d"
  find . -maxdepth 1 -type f -name 'sess_*' -mtime +$d -printf '.' | wc -c
done
```

Uma saída de exemplo seria `1 dias+: 412000`, `7 dias+: 398000`, `30 dias+: 351000`. Esse perfil conta uma história clara: quase tudo é lixo antigo, o GC não roda há meses, e o corte pode ser conservador sem perder eficácia.

## Apagar por idade, nunca por lote cego

A regra é apagar por idade, nunca por lote cego. Arquivo de sessão tem o `mtime` atualizado a cada gravação, então `-mtime` aproxima bem o critério de expiração.

### Dry run: veja a lista antes de deletar

```bash
find /var/cpanel/php/sessions/ea-php81 -maxdepth 1 -type f -name 'sess_*' \
  -mtime +2 -printf '%T@ %p\n' | head
```

Confira que só aparece o padrão esperado e que as datas fazem sentido. O `-maxdepth 1` evita sair do diretório se existir subdiretório de hash. O `-type f` evita tocar em qualquer coisa que não seja arquivo comum.

### Remover com -delete e por que não usar -exec rm

```bash
find /var/cpanel/php/sessions/ea-php81 -maxdepth 1 -type f -name 'sess_*' \
  -mtime +2 -delete
```

Se o volume for muito alto, `-delete` é preferível a `-exec rm` porque não faz fork por arquivo. Com milhões de entradas, rode em janela de baixa carga: a remoção massiva gera I/O de metadados pesado e, em `ext4` com diretório enorme, a travessia em si já é cara.

### Que corte de -mtime não desloga usuário ativo

O corte deve ser maior que o maior `gc_maxlifetime` legítimo entre os vhosts que gravam ali. Se uma aplicação mantém sessão de 24 horas, `-mtime +2` é seguro. `-mtime +0` com aplicações de sessão longa desloga gente logada.

### Sessão apagada não volta: use quarentena se o ambiente for sensível

Não há reversão para sessão apagada. O impacto de erro é logout de usuários ativos, não perda de dado persistente. Mesmo assim, se o ambiente for sensível, mova em vez de apagar:

```bash
mkdir -p /root/sess_quarentena
find /var/cpanel/php/sessions/ea-php81 -maxdepth 1 -type f -name 'sess_*' \
  -mtime +2 -exec mv -t /root/sess_quarentena {} +
```

Verifique o site por algumas horas e só então remova a quarentena. Atenção: a quarentena consome os mesmos inodes enquanto existir, então ela só ajuda se houver folga no filesystem de destino.

## O que o clean_user_php_sessions cobre e o que ele não cobre

O WHM traz o `clean_user_php_sessions`, documentado em [The clean_user_php_sessions Script](https://docs.cpanel.net/whm/scripts/the-clean_user_php_sessions-script/). Ele existe justamente para remover arquivos de sessão PHP expirados de contas de usuário, que é o trabalho que o GC do handler `files` deixa de fazer quando ninguém sorteia a varredura.

Trate o script como a rotina padrão e o `find` manual como ferramenta de emergência ou de diretório fora do padrão do cPanel. Antes de agendar qualquer coisa própria, leia a página de documentação da sua versão do cPanel: o comportamento, os caminhos cobertos e as opções disponíveis pertencem ao script, não a um wrapper improvisado. Se o seu `save_path` está fora dos caminhos que o cPanel gerencia, por `.user.ini` ou por `ini_set` na aplicação, não assuma cobertura automática.

Se for criar um cron próprio para um diretório customizado, mantenha três cuidados:

- Filtro explícito por nome (`-name 'sess_*'`) e por tipo (`-type f`).
- Caminho absoluto, sem variável não validada, porque um `find $DIR -delete` com `$DIR` vazio apaga a partir do diretório corrente.
- Log do que foi removido, com contagem, para você conseguir correlacionar queda de inode com a execução.

## Isolar o save_path para o acúmulo não voltar

Limpeza sem mudança de configuração é agenda recorrente. O arranjo que resolve de forma estrutural tem três partes.

### Um diretório por conta, definido no pool e não no .user.ini

Cada usuário grava em um diretório próprio, dentro do home dele, com permissão restrita ao dono (e ao usuário do PHP-FPM, se o handler for esse). Isso faz três coisas de uma vez: a contagem de inode passa a ser atribuível, o GC de um vhost deixa de alcançar sessão de outro, e um vazamento de ID de sessão por leitura de diretório deixa de ser possível entre contas.

Em PHP-FPM, defina no pool do domínio, não no `.user.ini`, usando `php_admin_value` para que a aplicação não consiga reapontar com `ini_set`.

### gc_maxlifetime coerente com o tempo de inatividade da aplicação

Depois do isolamento, o valor baixo deixa de ser perigoso para terceiros e passa a ser ferramenta sua. Alinhe o `gc_maxlifetime` ao tempo de inatividade que a aplicação realmente precisa tolerar. E-commerce com carrinho longo pede valor alto; painel administrativo pede valor curto.

### Confirme que gc_probability não está em zero

Confirme que `session.gc_probability` não está em 0 no vhost, ou que existe rotina externa cobrindo aquele diretório. Checagem rápida:

```bash
/opt/cpanel/ea-php81/root/usr/bin/php -i \
  | grep -E 'gc_probability|gc_divisor|gc_maxlifetime'
```

Com `gc_probability` em 0 e sem cron, o diretório só cresce. Esse é o cenário que produz o estouro de inode com disco livre.

### Redis ou memcached tiram a sessão do filesystem, com que custo

Se o volume de sessões é alto por natureza, mover o handler para Redis ou memcached elimina o consumo de inode e dá expiração nativa por TTL, sem depender de sorteio. O custo é uma dependência a mais e a necessidade de isolar por banco ou prefixo entre contas. Para a maioria dos sites em hospedagem compartilhada, o isolamento de `save_path` com GC funcionando já resolve e não vale a complexidade adicional.

## Checklist de diagnóstico em dez passos

| Passo | Comando | O que confirma |
|---|---|---||
| 1 | `df -i /home` e `df -h /home` | inode cheio com disco livre |
| 2 | `repquota -s /home` | se o limite é do filesystem ou da cota da conta |
| 3 | `php -i \ | grep save_path` no binário da versão | caminho efetivo do CLI |
| 4 | `.user.ini`, pool FPM, `ini_set` no código | sobreposições por conta |
| 5 | `var_dump(ini_get(...))` via HTTP | valor real do SAPI web |
| 6 | `find ... -name 'sess_*' -printf '.' \ | wc -c` | tamanho do acúmulo |
| 7 | `find ... -mtime +N -printf` (dry run) | perfil por idade antes de apagar |
| 8 | `find ... -mtime +N -delete` | limpeza só do expirado |
| 9 | `df -i` de novo | inode recuperado, com número |
| 10 | isolar `save_path`, ajustar `gc_maxlifetime`, garantir varredura | não volta |

Um detalhe que fecha o ciclo: anote o número do passo 1 e do passo 9 em algum lugar com data. Na próxima vez que o inode subir, a diferença entre as duas medições dá a taxa real de acúmulo daquele ambiente, e com ela você escolhe a frequência do cron em vez de chutar.

