Processi e risorse

Approfondimento · Linux

Processi e risorse

Un processo non è un programma: è un programma in esecuzione, con un PID, uno stato, una gerarchia, dei file descriptor aperti e delle risorse che il kernel gli concede. Capire fork, exec, i segnali, lo scheduler, i limiti e i cgroup è ciò che separa “riavvia e spera” da un’indagine vera. Questa pagina parte dal ciclo di vita e arriva a /proc, cgroup v2, namespace, OOM killer e diagnostica dei processi bloccati.

In breve. Tre comandi coprono metà del lavoro: ps -eo pid,ppid,stat,pcpu,pmem,etime,cmd --sort=-pcpu per vedere chi consuma, cat /proc/PID/status per capire in che stato è e systemd-cgls per sapere in quale cgroup vive. La regola è sempre la stessa: prima si misura, poi si limita, solo alla fine si uccide.

Per la struttura del file system e i permessi c’è File system e permessi; per i moduli e i parametri che regolano scheduler e memoria c’è Il kernel e la sua gestione. Qui si presume una shell già funzionante e un sistema con systemd.

Programma, processo e PID

Il kernel descrive ogni processo con una struttura interna, task_struct, che contiene lo stato, i registri, lo spazio di indirizzamento, i file descriptor, i segnali, le priorità e i puntatori alle risorse condivise. Il PID è solo l’identificatore visibile nello spazio dei nomi corrente: lo stesso processo ha PID diversi in namespace diversi, e un thread ha un TID diverso dal TGID del processo a cui appartiene.

I PID vengono riutilizzati. Un programma che tiene un PID in un file e lo usa giorni dopo può colpire un processo completamente diverso: è la classica race che ha portato all’introduzione delle pidfd (pidfd_open, pidfd_send_signal), un handle stabile che non soffre del riuso.

# Identita del processo
ps -p $$ -o pid,ppid,pgid,sid,tty,stat,cmd
echo "PID della shell: $$"
echo "PID del padre: $PPID"

# Limiti e namespace del PID corrente
cat /proc/self/status
cat /proc/self/cgroup
readlink /proc/self/ns/pid
readlink /proc/self/ns/mnt

# PID massimo e PID liberi
cat /proc/sys/kernel/pid_max
cat /proc/loadavg

ps -p $$ mostra anche PGID (process group), SID (session) e TTY: sono le tre coordinate che servono per capire chi riceve un segnale da terminale e chi sopravvive alla chiusura della sessione.

fork, exec, wait e zombie

Su Linux un processo nasce quasi sempre da fork() o clone(). fork() duplica il processo: il figlio riceve una copia dello spazio di indirizzamento, ma le pagine sono condivise in copy-on-write finché uno dei due non scrive. I file descriptor vengono copiati e puntano alla stessa open file description: condividono offset e flag, non solo il numero. Il valore di ritorno distingue i due rami: 0 nel figlio, PID del figlio nel padre, −1 in caso di errore.

execve() non crea un processo: sostituisce l’immagine del processo corrente con un nuovo programma. Il PID resta lo stesso, i file descriptor aperti restano aperti (tranne quelli marcati FD_CLOEXEC), gli handler dei segnali tornano al default (quelli ignorati restano ignorati) e lo spazio di indirizzamento viene rimpiazzato. Se execve ritorna, è sempre un errore.

# La shell usa fork + exec per ogni comando esterno
strace -f -e trace=clone,execve,wait4 bash -c 'ls /tmp'

# Il figlio vede 0, il padre vede il PID
bash -c 'echo "padre $$"; ( echo "figlio $BASHPID, padre $PPID" )'

# wait: il padre raccoglie lo stato di uscita
bash -c 'sleep 1 & p=$!; wait "$p"; echo "exit=$?"'

Quando un processo termina, il kernel libera memoria e risorse ma conserva una voce con PID e stato di uscita finché il padre non chiama wait() o waitpid(). Quella voce è lo zombie: non consuma memoria utente, non si può uccidere, e occupa solo uno slot nella tabella dei PID. Se il padre muore prima, il figlio viene riadottato da PID 1 (o da un subreaper impostato con PR_SET_CHILD_SUBREAPER) e raccolto da lì.

# Zombie e processi senza padre
ps -eo pid,ppid,stat,cmd | awk '$3 ~ /^Z/'
ps -eo pid,ppid,stat,cmd | awk '$2 == 1'

# Chi e il padre di un PID
ps -o pid,ppid,stat,cmd -p PID
cat /proc/PID/status | grep -E '^(State|PPid|Threads|Sig)'

# Stato di uscita in forma leggibile
wait "$pid"; echo $?
# 128 + numero del segnale se il processo e stato ucciso

Un processo ucciso da un segnale non ha un exit code normale: la shell riporta 128 + N, dove N è il numero del segnale. 137 significa 128 + 9, quindi SIGKILL; 143 è SIGTERM. Nei container è il motivo per cui “exit 137” quasi sempre vuol dire OOM killer o docker kill.

Thread, task e segnali

I thread su Linux sono processi che condividono lo spazio di indirizzamento, i file descriptor, la tabella dei segnali e il filesystem corrente. Il kernel li crea con clone() e i flag CLONE_VM, CLONE_FS, CLONE_FILES, CLONE_SIGHAND e CLONE_THREAD. Ogni thread ha un TID, ma tutti condividono il TGID, che è il PID che si vede con ps.

La distinzione conta per i segnali: la disposizione è condivisa dal gruppo di thread, ma la maschera è per thread. Un segnale può essere consegnato a un thread qualsiasi che non lo blocca, oppure a un thread specifico con pthread_kill o tgkill.

# Thread di un processo
ps -eLf
ps -eLo pid,tid,class,rtprio,ni,pri,psr,pcpu,comm
ls /proc/PID/task

# Top per thread
top -H -p PID
htop   # F2 -> Display options -> Show custom thread names

# Stack e stato dei thread
cat /proc/PID/task/TID/status
cat /proc/PID/task/TID/stack 2>/dev/null

La maggior parte dei programmi usa il modello 1:1 di NPTL: un thread utente per thread kernel. Le goroutine di Go, i task di Java e le coroutine di altri runtime multiplexano molti task utente su pochi thread kernel, quindi ps -eLf mostra meno thread di quanti ne conti il linguaggio.

Stati e scheduler

Lo stato in ps è una lettera, ma racconta molto. R è in esecuzione o in coda per la CPU; S dorme in modo interrompibile; D dorme in modo non interrompibile, quasi sempre in attesa di I/O; T è fermato da un segnale o da un debugger; Z è uno zombie; I è un thread idle del kernel.

StatoSignificatoCome si sblocca
RRunning o runnableAspetta il suo turno di CPU
SSleep interrompibileUn segnale o l’evento atteso
DSleep non interrompibileSolo l’I/O o il driver; SIGKILL arriva dopo
TStoppedSIGCONT
ZZombieIl padre chiama wait
IIdle kernel threadNon consuma CPU; è normale

Dal kernel 6.6 lo scheduler fair è EEVDF (Earliest Eligible Virtual Deadline First), che ha sostituito CFS. L’idea è assegnare a ogni task una slice e una deadline virtuale, e servire prima chi è eleggibile con la scadenza più vicina. Per l’amministratore cambia poco: nice resta il modo normale per spostare il peso, e le classi real-time restano separate.

# Priorita e classe di scheduling
chrt -p PID
ps -eo pid,ni,pri,rtprio,class,psr,comm --sort=-pri | head

# Cambiare nice (solo root puo scendere sotto 0)
nice -n 10 comando-lungo
renice -n 5 -p PID
renice -n 5 -g PGID
renice -n 5 -u alice

# Affinita e NUMA
taskset -pc PID
taskset -c 0-3 comando
numactl --cpunodebind=0 --membind=0 comando
lscpu | grep -E 'NUMA|CPU\(s\)'

Le classi real-time (SCHED_FIFO, SCHED_RR) hanno priorità 1–99 e possono affamare il resto del sistema. Il kernel applica un limite: di default i task real-time possono occupare il 95% di ogni periodo di un secondo (sched_rt_runtime_us=950000, sched_rt_period_us=1000000). SCHED_DEADLINE è ancora diverso: si dichiarano runtime, deadline e periodo, e il kernel ammette il task solo se la domanda è sostenibile.

chrt -f 10 comando        # FIFO, priorita 10
chrt -r 20 comando        # round-robin
chrt -b 0 comando         # batch
chrt -i 0 comando         # idle
chrt -d --sched-runtime 5000000 \
  --sched-deadline 10000000 --sched-period 20000000 0 comando

cat /proc/sys/kernel/sched_rt_runtime_us
cat /proc/sys/kernel/sched_rt_period_us

Il load average non è la percentuale di CPU: conta i task in stato R e D. Un carico di 8 su una macchina a 4 core può significare CPU satura, ma anche otto processi bloccati su un disco lento. vmstat distingue i due casi con le colonne r e b.

uptime
cat /proc/loadavg
vmstat 1 5
# r = runnable, b = blocked, wa = iowait, st = steal in VM
mpstat -P ALL 1
sar -u 1 5

Segnali

Un segnale è una notifica asincrona. I segnali standard non si accodano: se ne arriva un secondo mentre il primo è pendente, viene perso. I segnali real-time (SIGRTMIN–SIGRTMAX) si accodano e possono portare un payload con sigqueue. Ogni segnale ha una disposizione: default, ignora, oppure un handler. SIGKILL e SIGSTOP non possono essere catturati, bloccati o ignorati.

SegnaleNumeroEffetto tipico
SIGHUP1Terminale chiuso o configurazione da ricaricare
SIGINT2Ctrl-C: interruzione
SIGQUIT3Ctrl-\: core dump
SIGKILL9Terminazione immediata, non gestibile
SIGSEGV11Accesso non valido alla memoria
SIGPIPE13Scrittura su una pipe senza lettori
SIGTERM15Richiesta di terminazione ordinata
SIGCHLD17Un figlio è terminato o fermato
SIGCONT18Riprende un processo fermato
SIGSTOP19Ferma il processo, non gestibile
SIGTSTP20Ctrl-Z: stop da terminale
SIGUSR110Definito dall’applicazione
SIGUSR212Definito dall’applicazione
SIGWINCH28La finestra del terminale ha cambiato dimensione

I numeri variano per architettura: su x86-64 SIGUSR1 è 10, su altre architetture può essere diverso. Non scrivere kill -10 in uno script portabile: usa il nome.

# Elenco dei segnali
kill -l
trap -l

# Inviare segnali
kill -TERM PID
kill -HUP PID
kill -0 PID          # verifica esistenza e permessi, non invia nulla
kill -TERM -- -PGID  # tutto il process group
pkill -TERM -u alice -f 'python worker'
pkill -HUP -x nginx
pgrep -a -u alice
pidwait PID          # aspetta la fine senza polling

kill -0 è il modo corretto per verificare se un processo esiste: ritorna 0 se esiste ed è raggiungibile, EPERM se esiste ma non abbiamo i permessi, ESRCH se non esiste. pkill -f cerca nella riga di comando completa e può colpire la shell che lo esegue: è una fonte classica di autogol.

# Script che chiude in modo pulito
#!/usr/bin/env bash
set -euo pipefail

cleanup() {
  echo "chiusura richiesta" >&2
  rm -f "$tmpfile"
}
trap cleanup EXIT INT TERM

tmpfile=$(mktemp)
sleep 1000 &
wait $!

SIGTERM è una richiesta, non una garanzia: un processo può ignorarla, gestirla male o restare bloccato in D. SIGKILL non viene consegnato finché il task non torna da una syscall non interrompibile; per questo un processo su un NFS bloccato può restare vivo anche dopo kill -9. In quel caso il problema è il mount o il driver, non il processo.

Job control e processi persistenti

La shell organizza i comandi in job e process group. Ctrl-Z invia SIGTSTP, Ctrl-C SIGINT, Ctrl-\ SIGQUIT. Il terminale consegna questi segnali al process group in foreground, non a tutti i processi della sessione. Quando il terminale si chiude, il kernel invia SIGHUP alla sessione e la shell può propagarlo ai job; nohup e disown servono a evitarlo.

comando-lungo &
jobs -l
fg %1
bg %1
disown %1
nohup comando-lungo >log.txt 2>&1 &
setsid comando-lungo </dev/null >log.txt 2>&1 &
timeout -s TERM 30 comando
timeout -s KILL 60 comando

nohup ignora SIGHUP e redirige l’output; setsid crea una nuova sessione e stacca il processo dal terminale di controllo. Nessuno dei due è un vero supervisore: se il processo muore, nessuno lo riavvia. Per lavoro che deve sopravvivere a logout, crash e riavvii, la risposta è un’unità systemd, non nohup.

# Sessione persistente interattiva
tmux new -s lavoro
tmux attach -t lavoro
tmux ls
screen -S lavoro
screen -r lavoro

# Servizio transiente, senza creare un file unit
systemd-run --unit=backup-oggi --property=Nice=10 \
  --property=IOSchedulingClass=best-effort \
  --property=IOSchedulingPriority=7 \
  /usr/local/bin/backup.sh

systemctl status backup-oggi
journalctl -u backup-oggi -f

systemd-run crea un’unità temporanea che sopravvive alla shell e viene gestita da systemd come qualsiasi servizio. Con --scope il comando resta nel contesto chiamante ma viene comunque tracciato in un cgroup; con --on-active=30m si crea un timer. È il modo corretto per lanciare un job una tantum senza scrivere un file in /etc/systemd/system.

Ispezionare un processo

/proc è la fonte primaria. Ogni directory /proc/PID espone stato, mappa di memoria, file aperti, working directory, eseguibile, variabili d’ambiente, limiti, cgroup e statistiche di scheduling. Gli strumenti come ps, top e lsof leggono quasi tutti da qui.

FileContenuto
statusStato, PPid, UID/GID, thread, segnali, memoria
statStato e tempi in formato compatto per ps
cmdlineArgomenti separati da NUL
environAmbiente separato da NUL
maps smaps_rollupMappature di memoria e riepilogo RSS/PSS
fd/File descriptor aperti, con symlink al bersaglio
cwd root exeDirectory corrente, radice, eseguibile
limitsLimiti soft e hard
cgroupGerarchia cgroup v2 di appartenenza
sched schedstatClasse, priorita, tempo di CPU, attese
ioByte letti e scritti, syscall di I/O
oom_score oom_score_adjPunteggio e aggiustamento OOM
stack wchanKernel stack e funzione di attesa
ns/Namespace di mount, PID, rete, utente e altri
# Vista d'insieme
ps -eo pid,ppid,pgid,sid,stat,ni,pri,psr,pcpu,pmem,rss,etime,cmd --sort=-pcpu | head -n 20
ps --forest -o pid,ppid,stat,cmd
pstree -aps PID

# Dettaglio
cat /proc/PID/status
tr '\0' ' ' < /proc/PID/cmdline; echo
tr '\0' '\n' < /proc/PID/environ
ls -l /proc/PID/fd
readlink /proc/PID/cwd /proc/PID/exe /proc/PID/root
cat /proc/PID/limits
cat /proc/PID/io
cat /proc/PID/smaps_rollup
cat /proc/PID/wchan; echo

ps con stat può aggiungere suffissi: s session leader, l multithread, + in foreground, < alta priorità, N bassa priorità. ps -eo stat,cmd e ps -eo pid,stat,cmd sono più leggibili di una tabella gigante.

# Chi tiene aperto un file o una directory
lsof -p PID
lsof +D /srv/app
fuser -vm /srv/app
fuser -k /srv/app   # attenzione: uccide

# File cancellati ancora aperti
lsof +L1
ls -l /proc/PID/fd | grep deleted

# Socket e connessioni del processo
ss -tupn
ss -ltnp | grep PID

Limiti, priorità e affinità

Ogni processo ha limiti soft e hard. Il soft è quello attivo, l’hard è il tetto massimo: un processo non privilegiato può abbassare l’hard e alzare il soft fino all’hard, ma non superarlo. ulimit agisce sulla shell e sui figli; prlimit può leggere e modificare un processo già in esecuzione, se si hanno i permessi.

ulimit -a
ulimit -n          # file descriptor
ulimit -u          # processi/thread per utente
ulimit -c          # dimensione core dump
ulimit -v          # spazio di indirizzamento
ulimit -s          # stack
ulimit -l          # memoria lockabile

ulimit -n 65535
ulimit -Hn         # hard limit

prlimit --pid PID
prlimit --pid PID --nofile=65535:65535
prlimit --pid PID --core=0:

I limiti di login arrivano da PAM (/etc/security/limits.conf e /etc/security/limits.d/), ma i servizi systemd non passano da PAM: per loro si usano LimitNOFILE=, LimitNPROC=, LimitCORE= nel file unit o nei drop-in. Il valore assoluto massimo dei file aperti è fs.nr_open; il tetto complessivo del sistema è fs.file-max.

systemctl show -p LimitNOFILE sshd.service
systemctl edit sshd.service
# [Service]
# LimitNOFILE=65535

cat /proc/sys/fs/nr_open
cat /proc/sys/fs/file-max
cat /proc/sys/fs/file-nr

nice va da −20 (più priorità) a 19 (meno priorità). Un utente normale può solo aumentare il valore, cioè ridurre la priorità; per diminuirlo serve CAP_SYS_NICE. L’affinità limita i core su cui un processo può girare; su macchine NUMA, numactl lega anche la memoria a un nodo e riduce gli accessi remoti.

nice -n 19 tar -czf backup.tar.gz /srv
renice -n 10 -p PID
ionice -c 2 -n 7 -p PID
ionice -c 3 -p PID          # idle: solo quando il disco e libero
taskset -c 0,1 -p PID
taskset -pc PID
chrt -p PID

# Verifica
ps -o pid,ni,pri,psr,cmd -p PID
cat /proc/PID/sched | head -n 5

ionice dipende dallo scheduler I/O: con BFQ e CFQ ha effetto pieno, con mq-deadline e kyber l’effetto è limitato o nullo. Le priorità I/O per cgroup (io.weight) sono spesso più efficaci di ionice per limitare un servizio.

cgroup v2

I cgroup v2 organizzano i processi in una gerarchia unica e distribuiscono risorse in modo proporzionale. systemd è il gestore normale: ogni servizio, scope e sessione utente vive in un cgroup, e i limiti si impostano tramite le proprietà delle unità. La gerarchia è montata su /sys/fs/cgroup; se stat -fc %T risponde cgroup2fs, il sistema è in modalità unificata.

stat -fc %T /sys/fs/cgroup
mount | grep cgroup
systemd-cgls
systemd-cgtop
cat /sys/fs/cgroup/cgroup.controllers
cat /sys/fs/cgroup/cgroup.subtree_control

I controller principali sono cpu, cpuset, memory, io, pids, rdma, hugetlb e misc. Un controller compare in cgroup.controllers del padre e va abilitato nei figli scrivendo in cgroup.subtree_control. Vale la no internal process constraint: un cgroup che distribuisce controller ai figli non può avere processi propri, quindi i servizi stanno nelle foglie.

FileSignificatoEsempio
memory.maxLimite rigido di memoria1G oppure max
memory.highSoglia di throttling, non kill800M
memory.currentUso correntelettura
memory.eventsContatori high, max, oom, oom_killlettura
cpu.maxQuota e periodo in microsecondi50000 100000 = 50%
cpu.weightPeso relativo, 1–10000100
cpu.statTempo usato e throttlinglettura
io.maxLimiti byte e IOPS per dispositivo8:0 rbps=104857600
pids.maxNumero massimo di task512
cgroup.freezeCongela tutti i task1 / 0
cgroup.killUccide l’intero sottoalbero1
# Limiti via systemd, persistenti
systemctl set-property sshd.service MemoryMax=512M
systemctl set-property sshd.service CPUQuota=50%
systemctl set-property user-1000.slice MemoryHigh=4G
systemctl set-property user-1000.slice TasksMax=2048

# Verifica
systemctl show sshd.service -p MemoryMax -p CPUQuotaPerSecUSec
cat /sys/fs/cgroup/system.slice/sshd.service/memory.max
cat /sys/fs/cgroup/system.slice/sshd.service/memory.current
cat /sys/fs/cgroup/system.slice/sshd.service/memory.events
cat /sys/fs/cgroup/system.slice/sshd.service/cpu.stat

systemctl set-property scrive un drop-in persistente e ricarica l’unità. MemoryHigh rallenta il gruppo quando supera la soglia, MemoryMax è il muro: oltre, il kernel uccide un processo del cgroup. Per un job temporaneo si usa systemd-run con le stesse proprietà.

# Limiti manuali su un cgroup creato a mano
sudo mkdir /sys/fs/cgroup/demo
echo '+memory +cpu +pids' | sudo tee /sys/fs/cgroup/cgroup.subtree_control
echo 1G | sudo tee /sys/fs/cgroup/demo/memory.max
echo '50000 100000' | sudo tee /sys/fs/cgroup/demo/cpu.max
echo 256 | sudo tee /sys/fs/cgroup/demo/pids.max
echo $$ | sudo tee /sys/fs/cgroup/demo/cgroup.procs

# Congelare e uccidere un sottoalbero
echo 1 | sudo tee /sys/fs/cgroup/demo/cgroup.freeze
echo 1 | sudo tee /sys/fs/cgroup/demo/cgroup.kill

Attenzione: spostare la shell corrente in un cgroup creato a mano può renderla difficile da recuperare se il cgroup viene rimosso. In produzione si lascia fare a systemd, che gestisce gerarchia, delegate e cleanup.

Namespace

I namespace limitano ciò che un processo può vedere; i cgroup limitano ciò che può consumare. È la coppia che sta alla base dei container. I namespace principali sono mount, PID, rete, IPC, UTS, utente, cgroup e time.

NamespaceIsolaFlag
MountPunti di mount e gerarchia dei fileCLONE_NEWNS
PIDNumerazione dei processiCLONE_NEWPID
NetworkInterfacce, rotte, firewall, socketCLONE_NEWNET
IPCCode, semafori e memoria condivisa System VCLONE_NEWIPC
UTSHostname e domain nameCLONE_NEWUTS
UserUID/GID e capabilityCLONE_NEWUSER
CgroupVista della gerarchia cgroupCLONE_NEWCGROUP
TimeOffset degli orologiCLONE_NEWTIME
lsns
lsns -t pid
readlink /proc/PID/ns/*

# Entrare nei namespace di un processo
nsenter -t PID -m -u -i -n -p
nsenter -t PID -n -- ip addr

# Nuovo namespace PID con una shell
unshare --fork --pid --mount-proc bash
ps -ef   # dentro si vede un albero ridotto

# User namespace non privilegiato, se abilitato dalla distribuzione
unshare -Ur bash
id
cat /proc/self/uid_map

Nel namespace PID il primo processo è PID 1 e ha un trattamento speciale: il kernel ignora i segnali senza handler, tranne quelli inviati da un processo di un namespace antenato. Per questo kill -9 1 dentro un container spesso non fa ciò che si aspetta. nsenter è anche il modo per ispezionare un container che non espone una shell.

# Rete isolata con iproute2
sudo ip netns add lab
sudo ip netns exec lab ip link
sudo ip netns exec lab bash
sudo ip netns del lab

# Ispezionare un container Docker o Podman
docker inspect -f '{{.State.Pid}}' nome
sudo nsenter -t PID -n -p
podman top nome pid user comm args

Memoria e OOM killer

free mostra la memoria libera, ma il numero che conta è available: include la page cache che il kernel può scartare. free basso con available alto è normale e sano. La memoria di un processo si legge meglio con RSS (pagine residenti), PSS (quota proporzionale delle pagine condivise) e USS (solo pagine private). smaps_rollup dà PSS e USS in un colpo solo.

free -h
cat /proc/meminfo | grep -E 'MemTotal|MemFree|MemAvailable|Buffers|Cached|Swap'
vmstat 1

cat /proc/PID/smaps_rollup | grep -E 'Rss|Pss|Private'
pmap -x PID
ps -o pid,rss,vsz,pmem,cmd -p PID
smem -tk
ps_mem

L’OOM killer interviene quando il kernel non riesce a soddisfare un’allocazione. Sceglie un processo in base a un punteggio che tiene conto di memoria usata, durata e oom_score_adj (−1000–1000). −1000 esclude un processo quasi del tutto, 1000 lo rende il primo candidato. Nei cgroup, l’OOM è locale: si uccide un processo del gruppo che ha superato memory.max, non per forza l’intero sistema.

cat /proc/PID/oom_score
cat /proc/PID/oom_score_adj
choom -p PID
choom -n -500 -p PID
echo -500 | sudo tee /proc/PID/oom_score_adj

cat /sys/fs/cgroup/system.slice/sshd.service/memory.events
cat /sys/fs/cgroup/system.slice/sshd.service/memory.oom.group
cat /sys/fs/cgroup/system.slice/sshd.service/memory.pressure

dmesg -T | grep -i -E 'oom|killed process'
journalctl -k | grep -i oom

systemd-oomd è un demone che anticipa l’OOM classico usando PSI (Pressure Stall Information) e swap: uccide un cgroup quando la pressione di memoria è alta e il sistema sta per diventare ingestibile. Su desktop Fedora e Ubuntu è attivo per default; su server si configura con ManagedOOMSwap= e ManagedOOMMemoryPressure=.

systemctl status systemd-oomd
oomctl
cat /proc/pressure/cpu
cat /proc/pressure/memory
cat /proc/pressure/io

cat /proc/sys/vm/overcommit_memory
cat /proc/sys/vm/overcommit_ratio
grep -E 'CommitLimit|Committed_AS' /proc/meminfo
cat /proc/sys/vm/swappiness

overcommit_memory=0 è la euristica predefinita, 1 consente sempre, 2 applica un limite rigoroso basato su CommitLimit. Con 2 le allocazioni possono fallire prima che la memoria finisca, il che è desiderabile su alcuni database e indesiderabile altrove. swappiness regola la propensione a spostare pagine anonime in swap; sui server con swap piccolo si tiene basso, ma 0 non disattiva lo swap.

Diagnostica e recupero

Un processo lento non è per forza un processo che usa CPU. Prima si guarda lo stato, poi si distingue CPU, memoria, I/O e attesa. vmstat, iostat, pidstat e mpstat coprono quasi tutto; strace e perf servono quando il problema è dentro il processo.

SintomoPrima verificaPoi
Load alta, CPU bassavmstat 1, colonna bps -eo stat,wchan,cmd, iostat -xz 1
Processo in Dcat /proc/PID/wchandmesg -T, /proc/PID/stack, NFS o disco
Memoria che crescesmaps_rollup, pmap -xvalgrind, heaptrack, MALLOC_ARENA_MAX
CPU al 100%top -H, pidstat -u 1perf top -p PID, strace -c
I/O elevatoiotop -oPa, pidstat -d 1ionice, io.max, dimensione dei file
Processo che non muoreps -o stat,wchanmount NFS, driver, echo w > /proc/sysrq-trigger
Crash improvvisocoredumpctl listcoredumpctl debug, journalctl -k
# Chi consuma cosa
pidstat -u -r -d -w 1 5
iostat -xz 1 5
mpstat -P ALL 1 5
iotop -oPa
atop 1

# Tracciare un processo senza fermarlo
strace -f -tt -T -p PID
strace -f -c -p PID
strace -f -e trace=openat,read,write -p PID

# Profilare
perf top -p PID
perf stat -p PID sleep 5
perf record -F 99 -g -p PID -- sleep 10
perf report

# BPF quando serve
bpftrace -e 'tracepoint:sched:sched_switch { @[comm] = count(); }'

strace rallenta il processo e può alterare il comportamento di un servizio in produzione; usarlo per pochi secondi, con -c o con un filtro. perf ha meno overhead ma richiede kernel con supporto e permessi (perf_event_paranoid). bpftrace è potente ma va usato sapendo cosa si sta osservando.

# Processi bloccati: sysrq (solo se si sa cosa si sta facendo)
cat /proc/sys/kernel/sysrq
echo w | sudo tee /proc/sysrq-trigger
dmesg -T | tail -n 100

# Task bloccati da troppo tempo
cat /proc/sys/kernel/hung_task_timeout_secs
dmesg -T | grep -i 'blocked for more than'

# Core dump
ulimit -c
cat /proc/sys/kernel/core_pattern
coredumpctl list
coredumpctl info PID
coredumpctl debug PID

# Servizio ostinato
systemctl status nome.service
systemctl kill -s SIGKILL nome.service
systemctl reset-failed nome.service

Su Red Hat c’è anche abrt per la raccolta dei crash; su Debian e Ubuntu systemd-coredump è il percorso normale. In entrambi i casi il core dump non è la diagnosi: è la prova da portare a chi conosce il programma.

Regola d’oro. kill -9 è l’ultima riga, non la prima. Prima si guarda lo stato, si legge wchan, si controlla dmesg, si verifica il cgroup e si prova SIGTERM. Un processo in D non muore perché il kernel non può interrompere l’I/O: ucciderlo è teatro, non amministrazione.

Domande frequenti e casi pratici

Le domande che tornano sono poche, ma quasi mai si risolvono con un comando isolato. Qui ci sono i casi che capitano davvero, con sintomo, causa probabile e sequenza di verifica. Le risposte rapide in fondo servono per il resto.

Il processo è in D e non muore nemmeno con kill -9

Sintomo. ps mostra stato D, kill -9 ritorna senza errore ma il processo resta lì.

Causa. Il task è bloccato in una syscall non interrompibile, quasi sempre I/O su disco, NFS, FUSE o un driver. Il segnale viene consegnato solo quando il task torna in user space.

Soluzione. Identifica l’attesa, poi rimuovi la causa: server NFS irraggiungibile, disco che non risponde, mount bloccato. Se il disco sta fallendo, il problema non è il processo.

ps -o pid,stat,wchan:32,etime,cmd -p PID
cat /proc/PID/stack 2>/dev/null
cat /proc/PID/io
dmesg -T | tail -n 50
mount | grep -E 'nfs|cifs|fuse'

# NFS bloccato: smonta con prudenza
sudo umount -f /mnt/nfs
sudo umount -l /mnt/nfs

# Elenco dei task bloccati, se sysrq e abilitato
echo w | sudo tee /proc/sysrq-trigger
dmesg -T | tail -n 100

Ci sono processi zombie: posso ucciderli?

Sintomo. ps mostra stato Z e il processo non reagisce a nessun segnale.

Causa. Lo zombie è già morto: il kernel conserva solo PID e stato di uscita in attesa che il padre chiami wait(). kill -9 non ha alcun effetto.

Soluzione. Trova il padre e fai in modo che raccolga i figli: riavvia il servizio, correggi il programma, oppure verifica che PID 1 stia facendo il suo lavoro. Un SIGCHLD al padre a volte sblocca un handler che non raccoglie, ma non è una garanzia.

ps -eo pid,ppid,stat,etime,cmd | awk '$3 ~ /^Z/'
ps -o pid,ppid,stat,cmd -p PPID
kill -CHLD PPID

# Se il padre e un servizio
systemctl restart nome.service
journalctl -u nome.service --since '10 min ago'

Ho ucciso il processo ma la memoria non è tornata libera

Sintomo. free -h continua a mostrare poca memoria libera dopo la fine di un processo.

Causa. La page cache non è memoria sprecata: è cache che il kernel riusa. Oppure un file cancellato è ancora aperto, un processo è rimasto in D, o una cgroup trattiene cache e slab.

Soluzione. Guarda available, non free; cerca file cancellati ancora aperti; controlla memory.current e memory.stat del cgroup. drop_caches è solo diagnostica, non manutenzione.

free -h
ps -eo pid,stat,rss,pmem,cmd --sort=-rss | head -n 15
lsof +L1
slabtop -o | head -n 15

# Cgroup del servizio
cat /sys/fs/cgroup/system.slice/nome.service/memory.current
cat /sys/fs/cgroup/system.slice/nome.service/memory.stat | \
  grep -E '^(anon|file|slab|sock) '

# Reclaim mirato, se il kernel lo supporta
echo 1G | sudo tee /sys/fs/cgroup/system.slice/nome.service/memory.reclaim

# Solo per diagnosi, non da mettere in cron
sync; echo 3 | sudo tee /proc/sys/vm/drop_caches

Un servizio viene ucciso ogni notte: è l’OOM killer?

Sintomo. Il servizio sparisce, systemctl lo mostra fallito, dmesg contiene Out of memory: Killed process.

Causa. Il cgroup ha superato memory.max, oppure systemd-oomd ha deciso che la pressione di memoria era troppo alta. Può anche essere un job notturno che consuma tutta la memoria disponibile.

Soluzione. Distingui OOM del kernel e OOM di systemd-oomd, poi decidi se alzare il limite o correggere il consumo. Non disattivare l’OOM killer: senza, il sistema si blocca.

journalctl -k --since 'yesterday' | grep -i -E 'oom|killed process'
systemd-cgtop -m
cat /sys/fs/cgroup/system.slice/nome.service/memory.events
cat /sys/fs/cgroup/system.slice/nome.service/memory.max
journalctl -u systemd-oomd --since 'yesterday'
oomctl

# Margine: high rallenta, max uccide
systemctl set-property nome.service MemoryHigh=1G MemoryMax=1536M
systemctl show nome.service -p MemoryHigh -p MemoryMax

Il servizio è active ma non risponde

Sintomo. systemctl status dice active (running), ma la porta non risponde o le richieste vanno in timeout.

Causa. Il processo è vivo ma bloccato: deadlock tra thread, attesa I/O, pool esaurito, oppure un Type=simple che dichiara attivo un servizio che non ha ancora finito di avviarsi.

Soluzione. Guarda stato e stack dei thread, poi la rete. Per intercettare i blocchi usa un watchdog: con Type=notify e WatchdogSec= systemd considera fallito un servizio che non manda il keepalive.

systemctl status nome.service
systemctl show nome.service -p MainPID -p ActiveState -p SubState -p WatchdogUSec
ps -o pid,stat,wchan:32,etime,cmd -p PID
ss -ltnp | grep PID
strace -f -tt -p PID
gdb -p PID -batch -ex 'thread apply all bt'
journalctl -u nome.service --since '15 min ago'

Come avvio un processo al boot senza creare un’unità?

Risposta breve. Con systemd-run per un job immediato, ma le unità transienti non sopravvivono al riavvio. Per il boot serve un’unità abilitata, un timer persistente o cron @reboot.

# Job immediato, gestito da systemd
systemd-run --unit=job --property=MemoryMax=1G /usr/local/bin/job

# Timer relativo a adesso: sparisce al reboot
systemd-run --on-active=30m --unit=promemoria /usr/local/bin/notify

# Persistente: unita vera
sudo systemctl edit --force --full job.service
sudo systemctl enable --now job.service

# Alternativa rapida per veri one-shot
crontab -e
# @reboot /usr/local/bin/job

nohup non basta: il processo muore al logout

Causa. nohup ignora SIGHUP, ma non protegge da OOM, errori, chiusura della sessione systemd o pulizia dei processi utente. Non è un supervisore.

Soluzione. Per un servizio vero usa un’unità con Restart=on-failure e log nel journal. Per un processo utente che deve restare vivo senza login, abilita il linger.

loginctl show-user "$USER" -p Linger
sudo loginctl enable-linger "$USER"
systemctl --user enable --now job.service
journalctl --user -u job.service -f

# Unita di sistema
systemctl edit --force --full job.service
# [Service]
# ExecStart=/usr/local/bin/job
# Restart=on-failure
# RestartSec=5

Ho alzato ulimit -n ma il servizio ha ancora pochi file

Causa. ulimit vale per la shell e i suoi figli. I servizi systemd non passano da PAM e non leggono limits.conf: usano LimitNOFILE=.

Soluzione. Imposta il limite nell’unità o nei drop-in, ricarica systemd, riavvia il servizio e verifica /proc/PID/limits. Il tetto assoluto è fs.nr_open.

systemctl show nome.service -p LimitNOFILE
sudo systemctl edit nome.service
# [Service]
# LimitNOFILE=65535

sudo systemctl daemon-reload
sudo systemctl restart nome.service
cat /proc/PID/limits | grep 'open files'
cat /proc/sys/fs/nr_open

Load average alto con la CPU quasi ferma

Causa. Il load average conta anche i task in D. Se vmstat mostra b alto e wa alto, il collo di bottiglia è il disco, la rete o un mount.

vmstat 1 5
ps -eo pid,stat,wchan:32,pcpu,pmem,cmd | awk '$2 ~ /^D/'
iostat -xz 1 5
pidstat -d 1 5
cat /proc/pressure/io
dmesg -T | tail -n 50
sudo smartctl -a /dev/nvme0n1

Soluzione. Riduci il carico I/O con ionice o io.max, sposta i dati su un volume diverso, correggi il mount NFS, verifica la salute del disco. Aumentare la CPU non serve.

Come limito un processo a un core o a 1 GB di RAM?

Soluzione. Con taskset o AllowedCPUs= per l’affinità, e con MemoryMax= o un cgroup per la memoria. CPUQuota=100% corrisponde a un core.

taskset -c 0 comando
systemd-run --scope -p AllowedCPUs=0 -p MemoryMax=1G --unit=limitato \
  /usr/local/bin/job
systemd-run --scope -p CPUQuota=100% -p MemoryMax=1G \
  /usr/local/bin/job

systemctl set-property nome.service CPUQuota=50% MemoryMax=1G
cat /sys/fs/cgroup/system.slice/nome.service/cpu.stat

kill dice “Operation not permitted”

Causa. Il processo esiste ma non abbiamo i permessi: utente diverso, CAP_KILL mancante, user namespace, oppure /proc montato con hidepid.

id
capsh --print | grep -i cap_kill
ls -l /proc/PID
cat /proc/PID/status | grep -E '^(Uid|Gid|NSpid)'
sudo kill -TERM PID
sudo nsenter -t PID -p kill -TERM PID

Nota. Essere root in un container non significa avere CAP_KILL sui processi del namespace padre. In quel caso si agisce dall’host o si cambiano le capability del container.

Come vedo i processi dentro un container?

Soluzione. Ogni container ha un namespace PID proprio. Dall’host vedi i processi con il PID del namespace host; dentro il container ne vedi un albero ridotto.

podman top nome pid user comm args
docker top nome
podman inspect -f '{{.State.Pid}}' nome

# Entrare nei namespace del container
nsenter -t PID -p -m
cat /proc/PID/cgroup
systemd-cgls | grep -A5 nome

Il sistema ha ucciso un processo ma non trovo tracce nell’OOM killer

Causa. Può essere systemd-oomd, una OOMPolicy=stop che ferma l’intera unità, un crash con core dump, o un problema hardware. L’OOM del kernel non è l’unico modo in cui un processo sparisce.

journalctl -k --since '1 hour ago' | grep -i -E 'oom|segfault|killed'
journalctl -u systemd-oomd --since '1 hour ago'
oomctl
coredumpctl list
dmesg -T | grep -i -E 'oom|segfault|hardware error'
systemctl show nome.service -p OOMPolicy

Posso mandare SIGKILL a PID 1?

No, non nel senso che si immagina. PID 1 ignora i segnali per cui non ha un handler, SIGKILL compreso. In un container il runtime può terminarlo dall’esterno del namespace; sull’host si usa systemctl reboot o systemctl poweroff.

# Nel container: stop ordinato, poi kill dopo il timeout
podman stop -t 10 nome
docker stop -t 10 nome

# PID 1 che non raccoglie i figli: usa un init
podman run --init ...
docker run --init ...

Risposte rapide

DomandaRisposta
Come vedo tutti i thread?ps -eLf, top -H -p PID
Chi usa la porta 8080?ss -ltnp, lsof -i :8080
Come vedo l’ambiente di un processo?tr '\0' '\n' < /proc/PID/environ
Come fermo e riprendo un processo?kill -STOP PID, kill -CONT PID
Come aspetto la fine di un PID?pidwait PID
Come uccido un intero process group?kill -TERM -- -PGID
Come trovo il cgroup di un processo?cat /proc/PID/cgroup, systemd-cgls
Dove finiscono i core dump?coredumpctl, /proc/sys/kernel/core_pattern
Come cambio la priorità I/O?ionice -c 2 -n 7 -p PID
Come vedo il tempo di CPU di un processo?ps -o pid,time,etime,cmd -p PID

Fonti

Comportamenti e comandi verificati il 14 novembre 2026 su kernel 7.x e systemd. I default cambiano tra distribuzioni e versioni: lo scheduler fair è EEVDF dal kernel 6.6, cgroup v2 è la gerarchia unificata, systemd-oomd è attivo su molti desktop ma non su tutti i server. Prima di cambiare limiti o uccidere processi, controlla ps, /proc/PID/status e systemd-cgls.