Kernel

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.

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.

È 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.

RamoVersione al 14 novembre 2026A 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.

PercorsoContenuto
/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.

ParametroEffettoQuando 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
ChiaveValore tipicoEffetto
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

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.