Approfondimento · Linux
Il kernel e la sua gestione
Il kernel è il pezzo di software che parla con l’hardware, decide chi usa la CPU, gestisce memoria e file system e media ogni accesso alle periferiche. È anche il componente più delicato da aggiornare: un errore qui non fa crashare un programma, ma il sistema intero. Questa pagina spiega come è fatto, come si legge, come si aggiorna e come si ripara, con i comandi separati per Debian/Ubuntu e Red Hat/Fedora dove le differenze contano.
In breve. Non “ottimizzare il kernel” a caso: prima si misura, poi si cambia un parametro, poi si verifica. La maggior parte dei problemi nasce da un modulo mancante, da un initramfs non rigenerato o da un bootloader che punta al kernel sbagliato, non da un parametro esotico.
Per preparare il disco e installare un sistema da zero, la pagina Installazione da riga di comando copre ISO, USB, partizionamento e primo avvio; qui il kernel si presume già installato.
Scrivi cosa vuoi fare: la ricerca guarda comandi, descrizioni e titoli delle sezioni.
Che cosa gestisce il kernel
Il kernel gira in kernel space, con privilegi pieni sulla macchina, e offre ai processi un’interfaccia controllata: le chiamate di sistema. Tutto ciò che un programma fa passa da lì o da un file descriptor già aperto. Le responsabilità principali sono cinque.
- Scheduler. Decide quale processo usa la CPU e per quanto. Dal kernel 6.6 il default è EEVDF (Earliest Eligible Virtual Deadline First), che sostituisce il CFS.
- Memoria. Gestisce memoria virtuale, page cache,
swap, mappature e page fault. È anche il livello dove nascono
zswap,zrame l’OOM killer. - File system. Il VFS offre un’interfaccia comune a ext4, XFS, Btrfs, overlayfs, NFS e decine di altri. Il kernel non “conosce” i file: conosce inode, dentry e operazioni.
- Rete. Stack TCP/IP, netfilter, socket, driver delle schede e namespace di rete.
- Driver e sicurezza. Moduli per hardware, firmware, LSM come SELinux e AppArmor, seccomp, capability, namespace e cgroup.
È monolitico ma modulare: le funzioni usate all’avvio sono
compilate dentro l’immagine, il resto sta in moduli
.ko caricati quando servono. Questa distinzione spiega
perché un sistema può avere lo stesso kernel e
comportarsi diversamente: cambiano i moduli caricati, i parametri e il
firmware.
La versione si legge con uname. Il formato è
MAJOR.MINOR.PATCH, seguito da un suffisso che dice chi ha
costruito il pacchetto:
uname -r # 7.3.4-arch1-1, 6.12.0-55.9.1.el10_0, 6.14.0-24-generic
uname -v # data e configurazione di build
uname -m # architettura: x86_64, aarch64, riscv64
uname -a # tutto insieme
Il suffisso non è decorativo: -generic è il
kernel Ubuntu, -amd64 quello Debian,
-arch1-1 quello Arch, .el10 quello RHEL 10.
Due macchine con lo stesso 7.3.4 possono avere patch,
configurazioni e driver molto diversi.
Mainline, stable e LTS
Il kernel non ha un unico ramo. Linus Torvalds pubblica la
mainline: ogni due settimane si apre la merge window,
poi seguono circa sette release candidate e una versione finale, con un
ciclo di nove-dieci settimane. Le stable sono
manutenzioni della mainline: ricevono solo correzioni, non nuove
funzionalità, e hanno un numero di patch che cresce
(7.3.1, 7.3.2, ...). Le longterm
o LTS sono stable scelte per durare di più,
in genere almeno due anni, e vengono mantenute anche oltre quando
servono a distribuzioni e produttori.
| Ramo | Versione al 14 novembre 2026 | A cosa serve |
|---|---|---|
| Mainline | 7.3 (18 ottobre 2026) | Nuove funzionalità, sviluppo, test |
| Stable | 7.3.4 (10 novembre 2026) | Correzioni sopra la mainline, per chi vuole il nuovo |
| Longterm | 6.18.63, 6.12.117 | Base per server e distribuzioni con supporto lungo |
| Longterm precedenti | 6.6, 6.1 | Hardware e prodotti che restano su una base vecchia |
La 7.0 è uscita il 12 aprile 2026; la 7.3 è la stable corrente a novembre. Ogni distribuzione, però, non insegue kernel.org: congela una base e applica le proprie patch. Debian 13 usa la serie 6.12, RHEL 10 la 6.12, Ubuntu 24.04 parte dalla 6.8 e riceve kernel HWE con le point release, Mint 22.3 usa la 6.14 (o la 7.0 sulle ISO HWE), Kali 2026.3 la 7.1.5. Il numero che conta per la sicurezza è quello del pacchetto della distribuzione, non quello di kernel.org.
LTS non significa eterno. Anche una longterm riceve solo correzioni mirate e, prima o poi, va in fine vita. Se un fornitore promette “supporto fino al 2035”, sta parlando del proprio contratto, non del ramo kernel.org. La domanda giusta è: chi applica le patch, e con quale ritardo?
Cosa c’è in /boot e /lib/modules
Un kernel installato lascia tracce in due posti. In /boot
stanno gli artefatti che servono al bootloader; in
/lib/modules/<release> stanno i moduli e i metadati
che il kernel carica dopo. Conoscere questi file evita di
“reinstallare tutto” quando basta rigenerare un initramfs.
| Percorso | Contenuto |
|---|---|
/boot/vmlinuz-<release> |
Immagine compressa del kernel (bzImage su x86) |
/boot/initrd.img-<release> |
initramfs su Debian/Ubuntu/Mint/Kali |
/boot/initramfs-<release>.img |
initramfs su RHEL/Fedora |
/boot/config-<release> |
Configurazione con cui è stato compilato |
/boot/System.map-<release> |
Simboli del kernel, utili per debug e crash dump |
/lib/modules/<release>/kernel/ |
Albero dei moduli .ko (o .ko.zst) |
/lib/modules/<release>/modules.dep |
Dipendenze tra moduli, generate da depmod |
/lib/modules/<release>/build |
Symlink ai sorgenti/header per compilare moduli esterni |
/lib/firmware |
Firmware caricato dai driver (Wi-Fi, GPU, NIC) |
Su alcune distribuzioni i moduli stanno in
/usr/lib/modules e /lib è un symlink;
il percorso logico resta lo stesso. vmlinuz è
l’immagine avviabile, vmlinux è il file ELF
non compresso che si usa per il debug. Se /boot è
una partizione separata, tienila almeno 1 GiB: con più kernel e
initramfs da 100–200 MiB lo spazio finisce in fretta.
ls -lh /boot/
file /boot/vmlinuz-$(uname -r)
ls /lib/modules/$(uname -r)/kernel/
du -sh /lib/modules/$(uname -r)
Leggere lo stato del sistema
Prima di cambiare qualcosa, guarda. Questi comandi rispondono alle domande più frequenti: che kernel sto usando, con quali parametri, quali moduli sono caricati, quali driver stanno gestendo l’hardware e che cosa ha detto il kernel all’avvio.
cat /proc/version
cat /proc/cmdline
cat /proc/sys/kernel/ostype
getconf LONG_BIT
# Configurazione del kernel in uso
grep CONFIG_PREEMPT /boot/config-$(uname -r)
zcat /proc/config.gz | grep CONFIG_MODULE_SIG # se CONFIG_IKCONFIG_PROC è attivo
# Moduli e driver
lsmod
lspci -k
lsusb -t
# Messaggi del kernel
dmesg -T | head -n 40
journalctl -k -b
journalctl --list-boots
dmesg mostra il ring buffer del kernel; con
-T aggiunge timestamp leggibili, con
--level=err,warn filtra i messaggi importanti.
journalctl -k legge lo stesso contenuto dal journal, che
sopravvive al riavvio e permette di vedere il boot precedente con
-b -1. lspci -k è spesso la risposta
più rapida a “quale driver sta usando questa scheda?”.
Un’altra informazione utile è il taint: un bitmask che dice se il kernel è “sporco”. I valori comuni sono 1 (modulo proprietario), 4096 (modulo fuori dall’albero) e 8192 (modulo non firmato). Un kernel taint non è rotto, ma le segnalazioni di bug su un kernel taint vengono spesso ignorate dagli sviluppatori.
cat /proc/sys/kernel/tainted
dmesg | grep -i taint
modinfo -F vermagic modulo
modinfo -F depends modulo
Moduli, dipendenze e blacklist
Un modulo è un pezzo di kernel caricabile a runtime. Si carica
con modprobe, che risolve le dipendenze leggendo
modules.dep; insmod carica un file senza
risolvere nulla ed è quasi sempre la scelta sbagliata.
modprobe -r scarica un modulo e le sue dipendenze non
usate; rmmod scarica solo quello indicato.
modprobe modulo
modprobe -r modulo
modinfo modulo
modprobe --show-depends modulo
lsmod | grep modulo
depmod -a
Il caricamento automatico si configura in
/etc/modules-load.d/*.conf (systemd) e, su Debian,
anche in /etc/modules. Le opzioni e le regole stanno in
/etc/modprobe.d/*.conf: options passa
parametri, alias associa un nome, blacklist
impedisce il caricamento automatico per alias, install
sostituisce il comando di caricamento.
# /etc/modprobe.d/blacklist-nouveau.conf
blacklist nouveau
options nouveau modeset=0
# Blocco “duro”: anche un modprobe esplicito fallisce
install nouveau /bin/false
# Caricamento automatico all'avvio
# /etc/modules-load.d/lab.conf
v4l2loopback
Dopo aver modificato una blacklist che riguarda il boot (per esempio
nouveau, oppure un driver di storage), rigenera l’initramfs:
update-initramfs -u -k all su Debian/Ubuntu,
dracut -f su RHEL/Fedora. Altrimenti la modifica vale solo
per il sistema già avviato.
Blacklist non è un divieto assoluto. Blocca
il caricamento automatico per alias, non un
modprobe nome esplicito. Per impedire davvero il
caricamento usa install nome /bin/false. E non
disabilitare un driver di storage o di input senza avere una console
di recupero pronta.
I parametri di un modulo si vedono in
/sys/module/<nome>/parameters/ e con
modinfo -p. Alcuni si possono cambiare a runtime
scrivendo nel file corrispondente, altri solo al caricamento. La
differenza è nel permesso del file: se è in sola lettura,
serve un modprobe con l’opzione giusta.
Parametri di boot e sysctl
Ci sono due livelli di configurazione. I parametri di
boot arrivano al kernel dal bootloader e valgono per
l’intera vita del boot; i sysctl sono variabili
runtime esposte in /proc/sys, modificabili a caldo e
persistenti tramite file di configurazione. Confonderli è una
fonte inesauribile di “ho messo il parametro ma non
funziona”.
I parametri attuali sono in /proc/cmdline. Per aggiungerne
uno in modo persistente, su Debian/Ubuntu si modifica
/etc/default/grub e si rigenera la configurazione; su
RHEL/Fedora grubby è più sicuro perché
aggiorna tutte le voci senza riscrivere il file a mano.
cat /proc/cmdline
# Debian/Ubuntu/Mint/Kali
sudoedit /etc/default/grub
# GRUB_CMDLINE_LINUX_DEFAULT="quiet splash"
# GRUB_CMDLINE_LINUX=""
sudo update-grub
# RHEL/Fedora
sudo grubby --info=ALL
sudo grubby --update-kernel=ALL --args="quiet"
sudo grubby --update-kernel=ALL --remove-args="quiet"
sudo grubby --default-kernel
# Arch, con GRUB
sudo grub-mkconfig -o /boot/grub/grub.cfg
Su RHEL con UEFI la configurazione rigenerata può finire in
/boot/efi/EFI/redhat/grub.cfg; su Fedora il file reale
è /boot/grub2/grub.cfg e quello nella ESP fa da
rimando. Se usi systemd-boot, i parametri stanno in
/boot/loader/entries/*.conf e si aggiornano con
bootctl. In tutti i casi, dopo la modifica verifica
/proc/cmdline al riavvio: è l’unica prova che
il parametro è arrivato.
| Parametro | Effetto | Quando usarlo |
|---|---|---|
quiet, splash |
Meno messaggi, schermata grafica | Desktop; toglili per diagnosticare |
loglevel=7, debug |
Messaggi kernel più verbosi | Problemi di driver o boot |
nomodeset |
Non carica i driver video in modalità kernel | Schermo nero con GPU recente |
acpi=off, noapic, pci=nomsi |
Disabilita parti di ACPI/APIC/MSI | Hardware difettoso o molto vecchio; ultima risorsa |
intel_iommu=on, amd_iommu=on |
Attiva IOMMU | Passthrough, isolamento, alcuni driver |
mitigations=off |
Disattiva le mitigazioni CPU | Mai su sistemi esposti: riduce la sicurezza |
systemd.unit=rescue.target |
Avvia in modalità rescue | Sistema che non arriva al login |
init=/bin/bash |
Avvia bash come PID 1 | Recovery estrema; root in sola lettura |
rd.break |
Ferma l’initramfs prima del root | Reset password, riparazione LVM/LUKS su RHEL |
console=ttyS0,115200n8 |
Console seriale | Server headless e macchine virtuali |
preempt=full |
Seleziona preemption completa a boot | Kernel con CONFIG_PREEMPT_DYNAMIC, latenza bassa |
sysctl: runtime e persistenza
sysctl legge e scrive i parametri del kernel. Un valore
scritto con -w vale fino al riavvio; per renderlo
persistente serve un file in /etc/sysctl.d/, applicato
all’avvio da systemd-sysctl. Il nome con i punti
corrisponde al percorso in /proc/sys:
vm.swappiness è
/proc/sys/vm/swappiness.
sysctl vm.swappiness
sudo sysctl -w vm.swappiness=10
sysctl -a | wc -l
# Persistente
sudoedit /etc/sysctl.d/99-lab.conf
# vm.swappiness = 10
# kernel.dmesg_restrict = 1
sudo sysctl --system
sudo sysctl -p /etc/sysctl.d/99-lab.conf
| Chiave | Valore tipico | Effetto |
|---|---|---|
vm.swappiness |
10–60 | Quanto il kernel preferisce lo swap alla cache |
vm.vfs_cache_pressure |
50–100 | Quanto aggressivamente recupera dentry e inode |
vm.dirty_ratio |
10–20 | Percentuale di RAM sporca prima di forzare la scrittura |
net.core.somaxconn |
4096 | Lunghezza massima della coda di accept |
net.ipv4.ip_forward |
1 | Inoltro IP: router, VPN, container |
net.ipv4.tcp_congestion_control |
bbr |
Algoritmo di congestione, se il modulo è disponibile |
fs.inotify.max_user_watches |
524288 | Watcher per IDE, editor e tool di build |
fs.file-max |
Dipende dal sistema | Numero massimo di file aperti nel sistema |
kernel.pid_max |
4194304 | PID massimi disponibili |
kernel.dmesg_restrict |
1 | Impedisce agli utenti non privilegiati di leggere dmesg |
kernel.kptr_restrict |
2 | Nasconde gli indirizzi del kernel nei file di debug |
kernel.yama.ptrace_scope |
1 | Limita ptrace ai processi figli, se Yama è attivo |
Non copiare valori da internet.
vm.swappiness=0 su un server con poca RAM può
peggiorare l’OOM; ip_forward=1 su una macchina
esposta cambia il modello di sicurezza. Misura prima e dopo, e
annota il valore precedente accanto alla modifica.
Aggiornare il kernel
Aggiornare il kernel è normale e necessario: porta correzioni di
sicurezza, supporto per hardware nuovo e fix di file system. Il rischio
si riduce tenendo un kernel precedente avviabile, leggendo le note di
rilascio e riavviando appena possibile. La regola pratica è:
aggiorna, riavvia, verifica con uname -r, e conserva
almeno una voce vecchia nel menu di boot.
Debian, Ubuntu, Mint e Kali
Il kernel arriva come pacchetto linux-image-*. I
metapacchetti (linux-image-amd64 su Debian,
linux-generic su Ubuntu) seguono la serie prevista; i
pacchetti HWE portano kernel più recenti sulle LTS. I vecchi
kernel restano installati finché non si fa pulizia.
sudo apt update
apt list --installed 'linux-image-*'
# Debian: serie stabile del rilascio
sudo apt install linux-image-amd64 linux-headers-amd64
# Ubuntu: kernel GA o HWE
sudo apt install linux-generic
sudo apt install linux-generic-hwe-24.04
sudo apt full-upgrade
sudo apt autoremove --purge
ls /boot/vmlinuz-*
autoremove --purge elimina i kernel vecchi, ma tiene
quello in uso e di solito almeno uno precedente. Se vuoi essere
prudente, marca a mano il kernel di riserva con
sudo apt-mark hold linux-image-<versione> e
rilascialo dopo qualche giorno. Su Ubuntu il file
/var/run/reboot-required e il comando
needrestart dicono se il riavvio è dovuto al
kernel o a una libreria.
RHEL, Fedora e derivate
Su RHEL/Fedora il kernel è composto da più pacchetti:
kernel-core, kernel-modules,
kernel-modules-extra, kernel-devel,
kernel-headers. dnf installa la nuova
versione accanto alla vecchia e lascia a
installonly_limit il compito di limitare quante
conservarne (il default è 3).
sudo dnf check-update kernel
sudo dnf upgrade kernel
sudo dnf install kernel-<versione>
sudo dnf repoquery --installonly
sudo dnf remove --oldinstallonly --setopt installonly_limit=2 kernel
grep installonly_limit /etc/dnf/dnf.conf
sudo grubby --default-kernel
sudo needs-restarting -r
needs-restarting -r esce con codice 1 se serve un riavvio;
fa parte di dnf-plugins-core. Dopo il riavvio,
uname -r deve mostrare la nuova release. Se non succede,
il bootloader sta scegliendo una voce vecchia: controlla
grubby --info=ALL e l’ordine in GRUB.
Arch, openSUSE e firmware
Su Arch il kernel è un pacchetto normale:
pacman -Syu linux linux-headers. Tieni anche
linux-lts come riserva: se il kernel rolling si rompe, la
voce LTS nel menu di boot salva la giornata. Su openSUSE si usa
zypper up kernel-default e zypper ps -s per
vedere quali processi usano file cancellati da un aggiornamento.
Il firmware è un capitolo separato. linux-firmware
contiene i blob per Wi-Fi, GPU e periferiche; i microcode CPU arrivano
da intel-microcode o amd64-microcode su
Debian/Ubuntu e da microcode_ctl su RHEL/Fedora. Per
BIOS, SSD e dock si usa fwupdmgr, che non c’entra
con il kernel ma con il firmware del dispositivo.
sudo fwupdmgr refresh --force
sudo fwupdmgr get-updates
sudo fwupdmgr update
# Debian/Ubuntu
sudo apt install linux-firmware intel-microcode
# RHEL/Fedora
sudo dnf install linux-firmware microcode_ctl
initramfs
L’initramfs è un archivio compresso che il bootloader carica
insieme al kernel. Serve a fare i primi passi quando il root non
è ancora montato: caricare i driver del disco, aprire LUKS,
attivare LVM o RAID, montare il root e passare il controllo a
init. Se manca un modulo o un firmware dentro
l’initramfs, il sistema si ferma con un messaggio del tipo
“unable to find a live medium” o “not found”.
Ogni famiglia ha il suo strumento. La regola è sempre la stessa: dopo aver cambiato moduli, blacklist, crittografia o configurazione dello storage, rigenera l’initramfs prima di riavviare.
# Debian/Ubuntu/Mint/Kali
sudo update-initramfs -u -k all
lsinitramfs /boot/initrd.img-$(uname -r) | head
# RHEL/Fedora
sudo dracut -f
sudo dracut --regenerate-all -f
lsinitrd /boot/initramfs-$(uname -r).img | head
# Arch
sudo mkinitcpio -P
lsinitcpio /boot/initramfs-linux.img | head
La configurazione cambia con lo strumento: Debian usa
/etc/initramfs-tools/initramfs.conf e
/etc/initramfs-tools/conf.d/ (per esempio
MODULES=most, COMPRESS=zstd, la variabile
RESUME per l’ibernazione); RHEL/Fedora usa
/etc/dracut.conf.d/*.conf; Arch usa
/etc/mkinitcpio.conf con la variabile HOOKS,
dove l’ordine conta. Un errore tipico è togliere
encrypt o lvm2 dagli hook e ritrovarsi un
sistema che non apre il root.
Con LUKS, verifica che /etc/crypttab sia corretto e che
l’initramfs contenga il modulo dm_crypt; con RAID,
rigenera /etc/mdadm/mdadm.conf e poi l’initramfs.
Per l’ibernazione serve resume=UUID=... nella
command line e la stessa UUID nel file di resume. Se il sistema usa
un’immagine unificata (UKI), kernel, initramfs e command line
sono firmati insieme: in quel caso si rigenera l’UKI, non solo
l’initramfs.
DKMS e moduli fuori dall’albero
I moduli che non stanno nell’albero del kernel (driver NVIDIA, VirtualBox, ZFS, alcuni driver Wi-Fi) vanno ricompilati a ogni cambio di kernel. DKMS automatizza questo passaggio: registra il modulo, tiene traccia delle versioni e lo ricostruisce quando arriva un kernel nuovo, a patto che siano installati gli header giusti.
dkms status
sudo dkms autoinstall
sudo dkms install -m nome -v versione
sudo dkms remove -m nome -v versione --all
# Header necessari
sudo apt install linux-headers-$(uname -r) # Debian/Ubuntu
sudo dnf install kernel-devel kernel-headers # RHEL/Fedora
sudo pacman -S linux-headers # Arch
Se dopo un aggiornamento un modulo DKMS non si carica, la prima cosa da
leggere è
/var/lib/dkms/<modulo>/<versione>/build/make.log.
Le cause più comuni sono header mancanti, un modulo non ancora
aggiornato per il nuovo kernel e la firma Secure Boot rifiutata. Il
messaggio Key was rejected by service appartiene
all’ultima categoria.
DKMS non è obbligatorio per tutti i moduli esterni: alcuni
progetti distribuiscono pacchetti già compilati per kernel
specifici, altri usano akmods su Fedora. In tutti i casi
il principio è lo stesso: il modulo deve corrispondere alla
release esatta (vermagic) del kernel in uso.
Secure Boot e firma dei moduli
Secure Boot verifica la catena di firme dal firmware al bootloader e, se configurato, al kernel e ai moduli. Su un sistema con Secure Boot attivo, un modulo non firmato non si carica. Le strade sono due: disattivare Secure Boot (semplice, ma indebolisce la catena) oppure firmare il modulo con una chiave enrolata nel firmware.
mokutil --sb-state
dmesg | grep -i secure
bootctl status | grep -i "secure boot"
cat /sys/kernel/security/lockdown
La firma con Machine Owner Key (MOK) è la procedura più
comune. Si genera una coppia di chiavi, si firma il modulo, si importa
la chiave pubblica con mokutil e si completa
l’enrollment al riavvio nella schermata MOK Manager.
# Genera la chiave (una volta sola)
openssl req -new -x509 -newkey rsa:2048 -keyout MOK.priv \
-outform DER -out MOK.der -days 36500 -subj "/CN=Adripedia MOK/"
# Firma il modulo
sudo kmodsign sha512 MOK.priv MOK.der modulo.ko
# Importa la chiave e completa l'enrollment al riavvio
sudo mokutil --import MOK.der
sudo mokutil --list-enrolled
modinfo -F signer modulo.ko
modinfo -F sig_key modulo.ko
Su sistemi con chiavi proprie e sbctl, il flusso è
diverso: si creano le chiavi, si enrolano nel firmware, si firma il
bootloader e i moduli con sbctl sign -s, e si verifica con
sbctl verify. sbctl enroll-keys --microsoft
mantiene anche le chiavi Microsoft, necessarie per opzioni ROM e
alcuni dispositivi. In tutti i casi, dopo un aggiornamento del kernel
i moduli vanno rifirmati o ricostruiti dal sistema che gestisce la
firma.
Secure Boot non è un antivirus. Verifica che il codice avviato sia firmato, non che sia sicuro. Un modulo firmato può avere bug; una chiave MOK compromessa permette di firmare qualsiasi cosa. Tratta la chiave privata come una chiave di firma del software: file separato, permessi stretti, backup.
Per un blocco più forte si usa
module.sig_enforce=1 nella command line, oppure
CONFIG_MODULE_SIG_FORCE=y in compilazione: il kernel
rifiuta anche i moduli firmati con chiavi non presenti nel portachiavi.
Il lockdown mode, visibile in
/sys/kernel/security/lockdown, limita ulteriormente
/dev/mem, kexec e accessi diretti al kernel.
Compilare un kernel
Compilare il kernel serve per hardware non ancora supportato, per applicare una patch, per ridurre il sistema a ciò che serve o per fare debug. Non è la prima cosa da fare quando qualcosa non funziona: prima si prova il kernel della distribuzione, poi si valuta. Servono sorgenti, toolchain, tempo e spazio (10–20 GiB).
# Dipendenze, per famiglia
sudo apt install build-essential libncurses-dev bison flex \
libssl-dev libelf-dev dwarves bc rsync
sudo dnf install gcc make ncurses-devel bison flex openssl-devel \
elfutils-libelf-devel dwarves bc rsync perl
sudo pacman -S base-devel bc libelf pahole cpio perl tar xz
Il modo più sicuro per partire è riusare la
configurazione del kernel in uso, poi aggiornarla alle nuove opzioni
con olddefconfig. Da lì si attiva ciò che
serve con menuconfig o con scripts/config.
Per un sistema embedded, localmodconfig riduce la
configurazione ai moduli attualmente caricati; per un desktop o un
server generico è troppo aggressivo.
cp /boot/config-$(uname -r) .config
make olddefconfig
# Modifica interattiva
make menuconfig
# Oppure da script
scripts/config --enable CONFIG_PREEMPT_RT
scripts/config --module CONFIG_NVME_CORE
scripts/config --set-str CONFIG_LOCALVERSION "-lab"
make olddefconfig
# Compilazione
make -j"$(nproc)"
sudo make modules_install
sudo make install
# Debian/Ubuntu: initramfs e GRUB
sudo update-initramfs -u -k all
sudo update-grub
# RHEL/Fedora: initramfs e GRUB
sudo dracut -f
sudo grub2-mkconfig -o /boot/grub2/grub.cfg
make install copia kernel, configurazione e
System.map in /boot e di solito invoca lo
script installkernel della distribuzione. Se vuoi un
pacchetto invece di file sparsi, usa make deb-pkg o
make rpm-pkg: è il modo giusto per distribuire un
kernel su più macchine e per disinstallarlo con il package
manager. make localyesconfig trasforma i moduli caricati
in componenti built-in, ma può produrre un kernel enorme.
Dopo il riavvio, uname -r deve mostrare il suffisso
scelto (per esempio -lab). Se il sistema non parte,
riavvia con il kernel precedente dal menu di GRUB e controlla
dmesg. Le cause più frequenti sono un modulo
storage mancante nell’initramfs, una configurazione troppo
minimal e un bootloader non aggiornato.
Vanilla non è la distribuzione. Il kernel di
kernel.org non contiene le patch, i firmware e le configurazioni
della tua distro. Un kernel compilato da sorgenti può perdere
driver proprietari, Secure Boot e integrazione con
dkms. Provalo in una VM o su una macchina di
laboratorio, non sul portatile che usi per lavorare.
Livepatch e realtime
Ci sono due esigenze diverse che vengono spesso confuse: applicare una correzione senza riavviare e ridurre la latenza. La prima si affronta con il live patching, la seconda con un kernel realtime.
Live patching
Il live patching sostituisce a runtime singole funzioni del kernel per
correggere una vulnerabilità senza reboot. Ubuntu offre
Livepatch con Ubuntu Pro (fino a cinque macchine personali), RHEL usa
kpatch, SUSE kGraft. Non è una
scorciatoia universale: funziona solo per patch preparate, non cambia
strutture dati, non aggiunge driver e non sostituisce un riavvio
pianificato.
# Ubuntu Livepatch
canonical-livepatch status --verbose
sudo canonical-livepatch enable <token>
canonical-livepatch list
# RHEL kpatch
sudo kpatch list
sudo kpatch load kpatch-<nome>.ko
sudo kpatch unload kpatch-<nome>.ko
Realtime
PREEMPT_RT è entrato nel mainline con il kernel 6.12: non
serve più un albero separato per la maggior parte dei casi.
Si abilita con CONFIG_PREEMPT_RT=y e si distribuisce con
pacchetti dedicati: linux-image-rt-amd64 su Debian,
kernel-rt su RHEL/Fedora, linux-realtime su
Ubuntu. Su kernel con CONFIG_PREEMPT_DYNAMIC si può
scegliere preempt=full al boot.
sudo apt install linux-image-rt-amd64 rt-tests
cyclictest -p 99 -m -n -i 1000 -l 10000
# Isolamento CPU e IRQ (esempio su 8 core)
# isolcpus=2-7 nohz_full=2-7 rcu_nocbs=2-7 irqaffinity=0-1
chrt -f 99 comando
rtla timerlat top
hwlatdetect --duration=60
Il realtime non rende il sistema “più veloce”:
riduce la latenza massima e la sua variabilità, spesso a scapito
del throughput. Su un desktop si traduce in meno scatti audio/video;
su una macchina industriale in un ciclo di controllo più
prevedibile. Va misurato con cyclictest e
rtla, non dichiarato.
Diagnostica e recovery
La diagnostica del kernel si fa per strati: prima i messaggi, poi i
moduli e i driver, poi le risorse (CPU, memoria, I/O), infine il
tracing. Non serve partire da perf se il problema è
un firmware mancante: dmesg lo dice subito.
# Messaggi e boot precedente
dmesg -T --level=err,warn
journalctl -k -b -1
journalctl -k | grep -i -E 'error|fail|firmware|oom'
# Risorse
vmstat 1
iostat -xz 1
slabtop -o
cat /proc/pressure/cpu /proc/pressure/memory /proc/pressure/io
# Driver e interrupt
lspci -k
lsusb -t
cat /proc/interrupts
cpupower frequency-info
sensors
L’OOM killer lascia una traccia precisa:
dmesg | grep -i 'killed process' mostra vittima, PID e
consumo. Un hung task o un soft lockup
indicano un thread bloccato nel kernel; un taint con
modulo proprietario rende la diagnosi più difficile. Per i
crash dump si usa kdump con
crashkernel= nella command line e
systemctl status kdump; su Ubuntu c’è anche
pstore, che conserva i messaggi del crash nella memoria
persistente del firmware.
Riparare un boot che non arriva
Dal menu di GRUB si preme e per modificare una voce al volo.
Le mosse più utili: togliere quiet splash per
vedere i messaggi, aggiungere nomodeset per i problemi
video, avviare systemd.unit=rescue.target per un sistema
semi-funzionante, oppure init=/bin/bash per una shell di
emergenza. Con init=/bin/bash il root è montato in
sola lettura: mount -o remount,rw / prima di modificare
qualsiasi cosa.
# Prompt grub>: trovare la partizione e avviare a mano
ls
ls (hd0,gpt2)/boot
set root=(hd0,gpt2)
linux /boot/vmlinuz-7.3.4 root=/dev/nvme0n1p2 ro
initrd /boot/initrd.img-7.3.4
boot
Su RHEL/Fedora, rd.break ferma l’initramfs prima del
passaggio al root e permette di riparare LUKS, LVM o la password di
root; dopo la modifica serve touch /.autorelabel se
SELinux è attivo. grub-reboot imposta una voce solo
per il prossimo avvio, utile per provare un kernel senza cambiare il
default. efibootmgr -v mostra le voci UEFI e
efibootmgr -o ne cambia l’ordine.
Per un blocco totale, il magic SysRq resta l’ultima risorsa:
Alt+Stampa+R (rimonta in
lettura), E (termina i processi), I (uccide
quelli rimasti), S (sync), U (rimonta in sola
lettura), B (reboot). La sequenza REISUB evita di perdere
dati rispetto a un reset. Va abilitata con
kernel.sysrq=1, e su alcune distribuzioni è
limitata per sicurezza.
Ordine di intervento. 1) Leggi
dmesg/journalctl -k. 2) Verifica moduli,
firmware e driver con lspci -k. 3) Controlla
initramfs e bootloader. 4) Misura CPU, memoria e I/O. 5) Solo dopo,
tracing con perf o bpftrace. La fretta
salta i primi tre passi e finisce sempre per reinstallare il
sistema.
Fonti
- kernel.org, Releases — mainline, stable e longterm; versioni al 10 novembre 2026.
- Linux Kernel Documentation — admin-guide, sysctl, module-signing, livepatch, RT e kernel parameters.
- Debian, Linux Kernel Handbook —
pacchetti
linux-image, initramfs e configurazione. - Ubuntu, Kernel — kernel GA/HWE,
Livepatch,
needrestart. - Red Hat, Managing the kernel —
grubby,dnf,kpatch,kdumpeinstallonly_limit. - Fedora, Kernel — aggiornamenti,
akmodse Secure Boot. - Arch Wiki, Kernel — moduli,
mkinitcpio, parametri e compilazione. - DKMS, Documentation — stato, ricostruzione e log dei moduli esterni.
mokutil,sbctlekmodsign— enrollment delle chiavi e firma dei moduli.
Versioni verificate il 14 novembre 2026: stable 7.3.4 (10 novembre 2026), longterm 6.18.63 e 6.12.117, kernel 7.0 uscito il 12 aprile 2026, PREEMPT_RT nel mainline dalla 6.12. Prima di aggiornare un sistema in produzione, controlla le note della distribuzione: le patch e le versioni dei pacchetti contano più del numero di kernel.org.