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.
Scrivi cosa vuoi fare: la ricerca guarda comandi, descrizioni e titoli delle sezioni.
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.
| Stato | Significato | Come si sblocca |
|---|---|---|
R | Running o runnable | Aspetta il suo turno di CPU |
S | Sleep interrompibile | Un segnale o l’evento atteso |
D | Sleep non interrompibile | Solo l’I/O o il driver; SIGKILL arriva dopo |
T | Stopped | SIGCONT |
Z | Zombie | Il padre chiama wait |
I | Idle kernel thread | Non 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.
| Segnale | Numero | Effetto tipico |
|---|---|---|
SIGHUP | 1 | Terminale chiuso o configurazione da ricaricare |
SIGINT | 2 | Ctrl-C: interruzione |
SIGQUIT | 3 | Ctrl-\: core dump |
SIGKILL | 9 | Terminazione immediata, non gestibile |
SIGSEGV | 11 | Accesso non valido alla memoria |
SIGPIPE | 13 | Scrittura su una pipe senza lettori |
SIGTERM | 15 | Richiesta di terminazione ordinata |
SIGCHLD | 17 | Un figlio è terminato o fermato |
SIGCONT | 18 | Riprende un processo fermato |
SIGSTOP | 19 | Ferma il processo, non gestibile |
SIGTSTP | 20 | Ctrl-Z: stop da terminale |
SIGUSR1 | 10 | Definito dall’applicazione |
SIGUSR2 | 12 | Definito dall’applicazione |
SIGWINCH | 28 | La 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.
| File | Contenuto |
|---|---|
status | Stato, PPid, UID/GID, thread, segnali, memoria |
stat | Stato e tempi in formato compatto per ps |
cmdline | Argomenti separati da NUL |
environ | Ambiente separato da NUL |
maps smaps_rollup | Mappature di memoria e riepilogo RSS/PSS |
fd/ | File descriptor aperti, con symlink al bersaglio |
cwd root exe | Directory corrente, radice, eseguibile |
limits | Limiti soft e hard |
cgroup | Gerarchia cgroup v2 di appartenenza |
sched schedstat | Classe, priorita, tempo di CPU, attese |
io | Byte letti e scritti, syscall di I/O |
oom_score oom_score_adj | Punteggio e aggiustamento OOM |
stack wchan | Kernel 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.
| File | Significato | Esempio |
|---|---|---|
memory.max | Limite rigido di memoria | 1G oppure max |
memory.high | Soglia di throttling, non kill | 800M |
memory.current | Uso corrente | lettura |
memory.events | Contatori high, max, oom, oom_kill | lettura |
cpu.max | Quota e periodo in microsecondi | 50000 100000 = 50% |
cpu.weight | Peso relativo, 1–10000 | 100 |
cpu.stat | Tempo usato e throttling | lettura |
io.max | Limiti byte e IOPS per dispositivo | 8:0 rbps=104857600 |
pids.max | Numero massimo di task | 512 |
cgroup.freeze | Congela tutti i task | 1 / 0 |
cgroup.kill | Uccide l’intero sottoalbero | 1 |
# 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.
| Namespace | Isola | Flag |
|---|---|---|
| Mount | Punti di mount e gerarchia dei file | CLONE_NEWNS |
| PID | Numerazione dei processi | CLONE_NEWPID |
| Network | Interfacce, rotte, firewall, socket | CLONE_NEWNET |
| IPC | Code, semafori e memoria condivisa System V | CLONE_NEWIPC |
| UTS | Hostname e domain name | CLONE_NEWUTS |
| User | UID/GID e capability | CLONE_NEWUSER |
| Cgroup | Vista della gerarchia cgroup | CLONE_NEWCGROUP |
| Time | Offset degli orologi | CLONE_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.
| Sintomo | Prima verifica | Poi |
|---|---|---|
| Load alta, CPU bassa | vmstat 1, colonna b | ps -eo stat,wchan,cmd, iostat -xz 1 |
Processo in D | cat /proc/PID/wchan | dmesg -T, /proc/PID/stack, NFS o disco |
| Memoria che cresce | smaps_rollup, pmap -x | valgrind, heaptrack, MALLOC_ARENA_MAX |
| CPU al 100% | top -H, pidstat -u 1 | perf top -p PID, strace -c |
| I/O elevato | iotop -oPa, pidstat -d 1 | ionice, io.max, dimensione dei file |
| Processo che non muore | ps -o stat,wchan | mount NFS, driver, echo w > /proc/sysrq-trigger |
| Crash improvviso | coredumpctl list | coredumpctl 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
| Domanda | Risposta |
|---|---|
| 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
man 2 fork,man 2 execve,man 2 wait,man 2 clone— creazione, sostituzione e raccolta dei processi.man 7 signal,man 2 kill,man 2 sigaction— segnali, maschere, disposizioni e code real-time.man 5 proc— interfaccia/proc, file per processo e parametri del kernel.man 7 cgroups,man 7 namespaces,man 1 unshare,man 1 nsenter— isolamento e controllo delle risorse.man 1 systemd-run,man 5 systemd.resource-control,man 5 systemd.exec— unità transienti, limiti e cgroup gestiti da systemd.man 1 prlimit,man 1 chrt,man 1 taskset,man 1 ionice,man 1 choom— limiti, priorità, affinità e OOM score.- Linux kernel documentation — scheduler, cgroup-v2, psi, proc, namespaces.
- procps-ng, util-linux, sysstat, systemd, bcc/bpftrace — strumenti e manuali dei rispettivi progetti.
- LWN.net — articoli su EEVDF, PSI, cgroup v2 e pidfd.
- Debian, Ubuntu, Red Hat e Arch Wiki — default delle distribuzioni, pacchetti e procedure di recupero.
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.