# Load alto e CPU baixa: achar o processo que satura o disco

Como ir do iostat até o PID, o cgroup e a consulta responsável, e por que %util engana em NVMe. Diagnóstico documental, com as fontes oficiais citadas.

> quando o load average sobe, as páginas penduram e a CPU fica em 20%, o gargalo quase sempre é fila de disco: processos em estado D (uninterruptible sleep) contam no load. Confirme com iostat -xz 1 olhando await e aqu-sz, nunca %util isolado, e chegue ao PID com pidstat -d e iotop -oPa.

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

---

## Load 30 com a CPU em 20%: o que o estado D significa

O padrão é reconhecível em dois comandos. O `uptime` mostra load average de 20, 30, 40. O `top` mostra `%Cpu(s)` com `us` e `sy` baixos e `wa` (iowait) alto. Nenhum processo consome CPU, mas o site não responde.

Isso acontece porque o load average no Linux conta processos em estado `R` (runnable) **e** em estado `D` (uninterruptible sleep). `D` é, quase sempre, processo bloqueado esperando I/O de bloco. Trinta workers do PHP-FPM esperando o mesmo disco produzem load 30 com CPU em 20%.

O primeiro filtro é separar os dois estados:

```bash
ps -eo state,pid,comm,wchan:32 | awk '$1 ~ /^D/'
```

Se a lista vier povoada de `php-fpm`, `mysqld`, `tar`, `rsync` ou `clamscan`, o gargalo é fila de disco, e não CPU. A documentação do cPanel sobre alto I/O de disco parte exatamente dessa leitura: identificar os processos presos em I/O antes de mexer em qualquer outra coisa ([How to Troubleshoot High Disk I/O Problems](https://docs.cpanel.net/knowledge-base/general-server-administration/how-to-troubleshoot-high-disk-io-problems/)).

## Por que %util em NVMe não indica saturação

`iostat -xz 1` é a visão de dispositivo. O que importa, por coluna (`r_await` e `w_await` existem desde o sysstat 9.1.3; `avgqu-sz` foi renomeado para `aqu-sz` e `svctm` foi removido na série 12.x, então em 11.x e anteriores espere `avgqu-sz` e `svctm`):

| Coluna | O que a ferramenta mede | Como ler |
|---|---|---||
| `r/s`, `w/s` | requisições de leitura/escrita concluídas por segundo | é o IOPS real do dispositivo |
| `rkB/s`, `wkB/s` | throughput em KB/s | separa "muitos I/O pequenos" de "poucos I/O grandes" |
| `r_await`, `w_await` | tempo médio, em ms, entre enfileirar e concluir a requisição | inclui tempo na fila, não só o serviço |
| `aqu-sz` | tamanho médio da fila de requisições | acima de 1 só indica saturação em dispositivo de fila única; em NVMe, o que vale é a subida conjunta com `await` acima da linha de base do dispositivo |
| `%util` | percentual de tempo com pelo menos uma requisição em voo | em NVMe e RAID, **não** significa saturação |

O erro mais comum é tratar `%util` como medidor de saturação. Em disco rotacional de fila única, 100% de `%util` realmente indicava disco no limite. Em NVMe, que processa dezenas de filas em paralelo, `%util` chega a 100% com o dispositivo trabalhando a uma fração da capacidade. O par que importa em hardware moderno é `await` subindo junto com `aqu-sz`: fila crescendo e latência crescendo é saturação de verdade.

Exemplo fictício de saída, para fixar a leitura:

```
Device    r/s     w/s   rkB/s   wkB/s  r_await  w_await  aqu-sz  %util
sda     12.00  980.00   96.00  7840.00   210.4    186.7   14.62  99.80
```

Neste exemplo, escrita pequena e aleatória (8 KB por operação), fila em 14 e `await` acima de 180 ms. Com números assim, qualquer requisição HTTP que toque o disco herda centenas de milissegundos. Trate os valores acima como ilustração do formato, não como medição.

## Do dispositivo saturado para o processo que satura

Dispositivo saturado não diz quem satura. Três ferramentas resolvem, em ordem de invasividade.

### pidstat -d, onde iodelay diz mais que volume lido

```bash
pidstat -d 1 10
```

Sai `kB_rd/s`, `kB_wr/s` e `iodelay` por processo. `iodelay` é o tempo que a task passou bloqueada esperando I/O, em ticks de clock, e costuma ser mais revelador que o volume: um processo que lê pouco mas espera muito está pagando latência, não banda.

Para agrupar por comando e descartar quem está zerado:

```bash
LC_TIME=POSIX pidstat -d 5 1 | awk 'NR>3 && ($4+$5)>0 {rd[$NF]+=$4; wr[$NF]+=$5}
  END {for (c in rd) printf "%-24s %10.2f %10.2f\n", c, rd[c], wr[c]}' \
  | sort -k2 -nr | head -20
```

O `awk` soma `kB_rd/s` e `kB_wr/s` por nome de comando e descarta quem está zerado; o `sort -k2` ordena por leitura, troque para `-k3` se o problema for escrita. Confira os índices das colunas na sua saída antes: com `LC_TIME=POSIX` o campo de hora ocupa uma coluna só, e aí `$4`, `$5` e `$NF` batem. Sem isso, o formato AM/PM adiciona uma coluna e desloca tudo.

### iotop -oPa, para agregar por processo e acumular o intervalo

```bash
iotop -oPa
```

- `-o`: mostra só quem tem I/O no intervalo.
- `-P`: agrega por processo, não por thread (sem isso, `mysqld` vira dezenas de linhas).
- `-a`: acumula desde o início da execução, o que evita decidir com base em um pico de um segundo.

`iotop` precisa de `CONFIG_TASK_IO_ACCOUNTING` no kernel e privilégio de root. A documentação do cPanel lista `iotop` entre os utilitários indicados para localizar o processo responsável pelo I/O alto.

### /proc/<pid>/io separa page cache de leitura física

Quando o PID já está na mão, o contador bruto do kernel fecha a conta:

```bash
cat /proc/12345/io
```

Os campos que interessam:

| Campo | Significado |
|---|---||
| `rchar` / `wchar` | bytes lidos/escritos por syscall, incluindo o que veio do page cache |
| `read_bytes` / `write_bytes` | bytes que realmente foram ao dispositivo de bloco |
| `cancelled_write_bytes` | escrita contabilizada e depois descartada (truncate, por exemplo) |

A diferença entre `wchar` e `write_bytes` é o diagnóstico em si. `wchar` alto com `write_bytes` baixo é aplicação escrevendo muito em arquivo que o page cache absorve. `read_bytes` alto com `rchar` próximo significa cache miss: o dado não cabe na RAM ou está sendo invalidado. É a diferença entre comprar disco e ajustar `innodb_buffer_pool_size`.

## MySQL no topo do iotop: achar o arquivo e a consulta

Processo `mysqld` no topo do `iotop` não encerra o caso: falta saber qual arquivo e qual consulta.

O `pt-ioprofile`, do Percona Toolkit, anexa `strace` ao processo por um intervalo curto e agrega as chamadas de I/O por arquivo:

```bash
pt-ioprofile --profile-pid $(pidof mysqld) --run-time 30 --cell times
```

O resultado lista o tempo gasto por arquivo. Se o topo for `ibdata1` ou `ib_logfile*`, é escrita de transação e checkpoint. Se for um `.ibd` específico, você tem o nome da tabela, e daí para o `slow query log` é um passo: a consulta que varre aquela tabela é a mesma que enche a fila.

Duas ressalvas sérias, e elas não são formalidade:

- `pt-ioprofile` usa `strace`, que **pausa** o processo a cada syscall interceptada. Em servidor de produção sob carga, isso degrada o MySQL durante a coleta. Use `--run-time` curto, em janela conhecida, e nunca como monitoramento contínuo.
- `strace` e `gdb` no mesmo processo colidem. Se houver qualquer coisa anexada ao `mysqld`, não rode.

Alternativa sem anexar nada ao processo: `SELECT * FROM sys.io_global_by_file_by_bytes LIMIT 20;` no MySQL 5.7 ou superior com Performance Schema ativo. Menos granular, risco zero.

## Seis origens frequentes de fila de disco e o que corrige cada uma

As origens mais frequentes de fila de disco em servidor web compartilhado ou dedicado, e o que cada uma pede:

| Origem | Assinatura | Correção que resolve de fato |
|---|---|---||
| Consulta sem índice varrendo tabela | `mysqld` com `read_bytes` alto, `.ibd` no topo do `pt-ioprofile` | índice ou reescrita da consulta |
| `innodb_buffer_pool_size` pequeno | leitura física alta em tabela que caberia na RAM | aumentar o buffer pool |
| Backup, `tar`, `rsync` ou antivírus | processo de nome óbvio no `iotop -oPa`, janela fixa no dia | `ionice -c2 -n7`, agendamento fora de pico, limite de banda |
| Sessões PHP em disco e cache de página ausente | muitos `php-fpm` em estado `D`, I/O pequeno e disperso | cache de objeto/página, sessão em memória |
| Log de erro em loop | arquivo único crescendo rápido, `wchar` enorme | corrigir o erro, não rotacionar mais rápido |
| Swap ativo | `si`/`so` no `vmstat 1` diferentes de zero | memória, não disco |

O caso do swap merece destaque porque é o que mais engana. Com swap em uso, o disco satura por falta de RAM, e trocar o disco ou o plano não corrige nada. Confira sempre com `vmstat 1` antes de concluir qualquer coisa sobre I/O.

## Limitar I/O por conta com LVE e cgroup v2

Em servidor com múltiplas contas, saber o processo é meio caminho. Falta o dono.

Para chegar ao cgroup de um PID:

```bash
cat /proc/12345/cgroup
```

Em hosts com CloudLinux, o LVE permite ver e limitar I/O por usuário. `lvetop` mostra o consumo corrente por LVE, incluindo colunas de I/O e IOPS. Os limites se aplicam com `lvectl`:

```bash
# limite por usuário (consulte lvectl --help na sua versão antes de aplicar)
lvectl set <id> --io=1024 --iops=1024
lvectl apply all
```

O `--io` é throughput em KB/s, `--iops` é operações por segundo. Aplicar throttle não torna o site do usuário mais rápido: torna o restante do servidor imune a ele. É contenção, não correção. A correção continua sendo o índice, o cache ou o agendamento do backup.

Se o servidor não tem CloudLinux, o equivalente é `io.max` no cgroup v2, com `MAJ:MIN` do dispositivo obtido via `lsblk`. E, para processos de manutenção, `ionice -c2 -n7 -p <pid>` só rebaixa a prioridade de verdade se o dispositivo estiver com `bfq`: classes e níveis de `ionice` são respeitados pelo BFQ (e eram pelo extinto CFQ, removido no kernel 5.0). Com `mq-deadline` ou `none`, que é o padrão da maioria das distros em NVMe, a syscall aceita o valor e o despacho ignora. Confira com `cat /sys/block/<dev>/queue/scheduler` e, se for o caso, troque com `echo bfq > /sys/block/<dev>/queue/scheduler` (vale até o reboot; em NVMe de alto IOPS o BFQ cobra CPU por requisição, meça antes de fixar). Sem `bfq`, o caminho é `io.max` no cgroup v2 ou mudar o agendamento do job.

## Seis perguntas a responder antes de pagar por mais IOPS

Upgrade resolve quando o trabalho de I/O é legítimo e já está otimizado. O teste honesto, na ordem:

- Há swap em uso? Se sim, é memória.
- `read_bytes` alto em tabela que caberia no buffer pool? Se sim, é configuração.
- O `slow query log` aponta consulta que varre tabela grande? Se sim, é índice.
- O pico coincide com backup ou antivírus? Se sim, é agendamento e `ionice`.
- O cache de página está desligado no site com mais tráfego? Se sim, é cache.
- Nada disso, `await` alto com `aqu-sz` alto o dia inteiro, em carga que já é a esperada? Aí sim: mais IOPS, NVMe, separar o volume do banco.

Das seis, só a última custa dinheiro recorrente. Vale gastar os trinta minutos de `pidstat`, `/proc/<pid>/io` e `pt-ioprofile` antes de assinar a sexta.

### Como reverter cada limite aplicado

Tudo que foi sugerido aqui é reversível e vale deixar anotado antes de aplicar:

- `ionice -c2 -n7 <comando>` vale só para o processo lançado e termina com ele. `ionice -c2 -n7 -p <pid>` altera um processo já em execução, e a mudança também morre com o processo. Nenhuma das duas formas sobrevive a reinício, e nenhuma tem efeito se o escalonador não for `bfq`.
- Limite de LVE volta com `lvectl set <id> --io=<valor anterior>` seguido de `lvectl apply all`; registre o valor anterior com `lvectl list` antes.
- `io.max` no cgroup v2 se remove escrevendo os pares chave=valor com `max`: `echo '259:0 rbps=max wbps=max riops=max wiops=max' > io.max`. Chave omitida na linha permanece com o valor anterior, e `MAJ:MIN max` sozinho é recusado com erro de parsing.
- `pt-ioprofile` desanexa o `strace` ao fim do `--run-time`; se interromper com `Ctrl+C`, confirme com `ps -eo pid,comm | grep strace` que nada ficou pendurado no `mysqld`.

## Referências

- cPanel, [How to Troubleshoot High Disk I/O Problems](https://docs.cpanel.net/knowledge-base/general-server-administration/how-to-troubleshoot-high-disk-io-problems/), consultado em 19/10/2026.

Os valores de `iostat` e os PIDs usados acima são exemplos construídos para ilustrar o formato da saída. Não são medição de laboratório da Napoleon Host.

