SSD Nodes Learn Hosting plans →
Guide Matt ConnorDi Matt Connor · Aggiornato 2026-10-30

Kernel Linux 7.2: novità e impatto su un VPS

Linux 7.2 introduce la schedulazione consapevole della cache con CONFIG_SCHED_CACHE: scopri cosa cambia e se un VPS guest può ottenere vantaggi reali.

Novità del kernel Linux 7.2

Il kernel Linux 7.2 è stato rilasciato il 16 agosto 2026. La novità più importante è la schedulazione consapevole della cache, implementata dietro la nuova opzione CONFIG_SCHED_CACHE. Lo scheduler ora cerca di mantenere i thread di uno stesso processo su CPU che condividono la stessa cache di ultimo livello (LLC). La release modifica inoltre il posizionamento delle CPU nei sistemi con capacità asimmetriche delle CPU e SMT: vengono preferiti i core completamente inattivi e vengono rifiutate le migrazioni non adatte verso sibling SMT occupati.

In una riga, il resto di 7.2: revisione del percorso fast commit di ext4, miglioramenti a MGLRU (il codice di reclaim della memoria basato sull'algoritmo least recently used multi-generazionale), un nuovo target device mapper dm-inlinecrypt per la cifratura inline dei dispositivi a blocchi e la rimozione dell'ultima chiamata strncpy() dal codice sorgente del kernel.

Un solo fatto determina se la funzionalità principale può esserti utile, quindi lo affrontiamo per primo. Il bilanciamento del carico consapevole della cache si attiva soltanto quando un nodo NUMA (non-uniform memory access) contiene più di una LLC. Questa topologia normalmente non è visibile a un guest VPS. Di conseguenza, nella maggior parte dei guest il codice è compilato ma non viene mai attivato. Per verificarlo servono due comandi, descritti nella sezione "Un guest VPS vede qualcosa di tutto questo?" più avanti.

Le fonti tecniche originali di questa pagina sono il changelog della versione 7.2 e la serie di patch sulla schedulazione consapevole della cache, consultati il 18 agosto 2026. I parametri regolabili di debugfs sono stati verificati nuovamente il 29 ottobre 2026 sul codice sorgente di Linux 7.2. Le fonti sono elencate verso la fine, così puoi confrontarle con il comportamento del tuo kernel.

Perché lo scheduler dove conoscere le cache

Un socket server moderno non ha una sola cache di ultimo livello. Un package AMD EPYC è composto da diversi core complex e ogni complex ha la propria cache L3. Anche i recenti processori Intel Xeon suddividono il socket in più domini di cache. Di conseguenza, un singolo nodo NUMA può contenere quattro, otto o più LLC separate e due thread dello stesso programma possono finire in cache diverse.

Questa disposizione introduce latenza. Quando due thread condividono una pagina presente in LLC diverse, ogni cache conserva una propria copia della cache line. Una scrittura su un lato invalida la copia sull'altro lato, quindi la lettura successiva deve attraversare l'interconnect oppure accedere alla memoria principale. Questo fenomeno è chiamato cache bouncing. Si manifesta come cicli trascorsi in attesa, non come tempo di inattività della CPU. Per questo è facile non rilevarlo osservando il load average.

Prima della versione 7.2, il load balancer assegnava i task usando il carico, l'utilizzo e le CPU inattive. Non disponeva di alcun dato che indicasse che "questi due task leggono la stessa memoria". La versione 7.2 aggiunge questa informazione usando un'approssimazione: i thread di un processo condividono lo stesso spazio degli indirizzi, quindi è ragionevole presumere che condividano anche i dati.

Come il kernel seleziona una LLC preferita

Il tracciamento è associato al processo, in mm_struct, la struttura del kernel che rappresenta uno spazio degli indirizzi. Il kernel campiona periodicamente dove sono in esecuzione i thread del processo e conta, per ogni LLC, quale quantità del processo risiede in ciascuna di esse. La LLC che contiene la quantità maggiore diventa la LLC preferita per l'intero processo. È questo valore singolo che viene letto dalle decisioni successive.

Durante il bilanciamento del carico, quando i task devono spostarsi tra gruppi dello scheduler, il kernel preferisce spostare i task che preferiscono già la LLC di destinazione ed evita di allontanare un task dalla LLC che preferisce.

I meccanismi di protezione sono importanti quanto la funzionalità, perché concentrare tutti i thread di un processo sotto carico in un unico dominio di cache può sovraccaricare quel dominio mentre il resto del socket rimane inutilizzato. I tunable si trovano in debugfs, il filesystem di debug del kernel, nella directory llc_balancing sotto /sys/kernel/debug/sched/:

  • enabled, con valore predefinito 1, è un semplice interruttore di attivazione e disattivazione dell'intera funzionalità.
  • aggr_tolerance accetta un valore senza segno a 32 bit, senza un limite massimo di 100, e stabilisce quanto aggressivamente il kernel aggrega. 0 impedisce l'idoneità all'aggregazione, ma lascia attivi la static key della funzionalità e i callback di accounting. 1, il valore predefinito, è l'impostazione prudente: l'aggregazione viene saltata quando il controllo della capacità dei thread attivi fallisce oppure quando l'ingombro di memoria supera la LLC con il bilanciamento NUMA attivo. Il normale bilanciamento del carico continua a spostare questi task. I valori pari o superiori a 100 rimuovono i limiti relativi all'ingombro e alla capacità dei thread attivi, ma i processi a thread singolo restano esclusi e continuano ad applicarsi i vincoli sul carico della migrazione.
  • overaggr_pct, con valore predefinito 50, imposta la soglia di utilizzo della LLC usata insieme all'utilizzo della sorgente e ai controlli dello sbilanciamento per decidere le migrazioni. Con un thread hardware per core, la soglia predefinita diventa 75%. Non è un limite assoluto per accettare i task aggregati.
  • imb_pct, con valore predefinito 20, imposta il margine percentuale usato nel confronto tra l'utilizzo della LLC di origine e quello della destinazione, per evitare sbilanciamenti eccessivi e il continuo spostamento dei task.
  • epoch_period, con valore predefinito di circa 10 ms (HZ/100; il file contiene il valore in jiffies), stabilisce la frequenza di raccolta dell'occupazione.
  • epoch_affinity_timeout, con valore predefinito di 5 epoch, pari a circa 50 ms, stabilisce per quanto tempo un processo inattivo conserva la propria preferenza prima che il kernel la elimini.

Leggere i valori in uso prima di modificarli, perché una distribuzione può fornire valori predefiniti diversi: sudo cat /sys/kernel/debug/sched/llc_balancing/aggr_tolerance. Una serie di patch pubblicata nel luglio 2026, dopo l'integrazione di 7.2, propone di dividere aggr_tolerance in aggr_tolerance_nr e aggr_tolerance_size. Una versione successiva del kernel potrebbe quindi elencare questi due file al suo posto.

Quali carichi di lavoro possono trarre vantaggio e quali no

I numeri riportati di seguito sono quelli pubblicati insieme alla serie di patch. Sono stati misurati su hardware di classe server, in alcuni casi con il parametro di tolleranza impostato su un valore aggressivo. Considerateli come lo scenario favorevole su bare metal, non come una garanzia per il vostro sistema.

GraficoReported gains from cache aware scheduling, server hardware, percent
I dati alla base di questo grafico
[
  {
    "label": "hackbench, 1 group, Xeon Sapphire Rapids",
    "gain_pct": 30.57
  },
  {
    "label": "schbench, 4 threads, p99 wakeup latency, Sapphire Rapids",
    "gain_pct": 37.78
  },
  {
    "label": "ChaCha20 run time reduction, AMD Genoa, aggressive tolerance",
    "gain_pct": 44
  }
]

Hackbench con un singolo gruppo è migliorato del 30.57%, mentre il tempo di esecuzione di ChaCha20 su AMD Genoa è diminuito del 44%. Tutti i 3 risultati sono stati ottenuti su hardware server con più LLC, controllato integralmente dal tester.

Un carico di lavoro che può trarre vantaggio presenta queste caratteristiche:

  • Più di un thread nello stesso processo, in modo che ci siano thread da raggruppare.
  • Condivisione effettiva tra questi thread, così che una cache line trasferita rappresenti un costo reale.
  • Un working set che rientra in una sola LLC, perché un processo più grande della cache non può ottenere località della cache spostandolo.
  • Capacità libera sulla macchina, in modo che lo scheduler possa scegliere realmente dove collocare il thread successivo.

Ecco invece i casi in cui non c'è nulla da guadagnare:

  • Una macchina già al massimo della capacità. Tutte le CPU sono occupate, quindi il posizionamento è obbligato e i vantaggi riportati si riducono.
  • Processi a thread singolo e pool di processi indipendenti che non condividono dati.
  • Un working set molto più grande della LLC, che l'impostazione prudente aggr_tolerance esclude intenzionalmente quando il bilanciamento NUMA è abilitato.
  • Un nodo che segnala una sola LLC, condizione in cui la funzionalità non viene mai attivata.

Esiste anche un costo, e la serie di patch lo dichiara esplicitamente. La raccolta dei dati sull'occupazione viene eseguita nel contesto del task e, in alcune esecuzioni, la latenza delle richieste è peggiorata perché questa attività ritardava il ritorno del task nello spazio utente. L'aggregazione può inoltre aumentare la variabilità della latenza anche quando migliora il throughput medio. Se vi interessa la coda della distribuzione più della media, misurate la coda del vostro sistema.

Un guest VPS vede qualcosa di tutto questo

La risposta dipende da due fatti.

Primo: la funzionalità dipende dalla topologia. Il bilanciamento del carico consapevole della cache viene abilitato solo quando all'interno di un nodo NUMA esiste più di una LLC; il kernel registra questa condizione durante la configurazione della topologia. Quando un nodo segnala una sola LLC, il percorso consapevole della cache resta inattivo, indipendentemente dai valori dei parametri regolabili.

Secondo: la topologia della cache che il guest rileva non è quella dell'host. È quella presentata dal modello CPU dell'hypervisor. Di norma, un guest KVM (kernel based virtual machine) non riceve la reale disposizione della cache L3 dell'host. Di conseguenza, il guest ragiona su una rappresentazione semplificata.

Verifica cosa vede il tuo guest:

systemd-detect-virt
lscpu --caches
for cache in /sys/devices/system/cpu/cpu*/cache/index*; do
  [ "$(cat "$cache/level")" = 3 ] && cat "$cache/shared_cpu_list"
done | sort -u

Gli indici della cache enumerano le voci; il file level identifica la L3. Una riga che elenca tutte le vCPU indica che il guest vede un unico dominio L3. A quel livello, quindi, la funzionalità non ha nulla da organizzare. La sola assenza di index3 non dimostra che la L3 sia assente. Controlla index*/level; se nessuna voce indica il livello 3, esamina il livello di cache più alto esposto e il relativo shared_cpu_list.

Esiste poi la doppia schedulazione, una limitazione da considerare per qualsiasi tenant. Il kernel del guest assegna i thread alle vCPU. Il kernel dell'host assegna i thread delle vCPU ai core fisici. Un guest che raggruppa con attenzione quattro thread sulle vCPU da 0 a 3 esprime una preferenza relativa a quattro thread dell'host. L'host è però libero di collocarli in domini di cache fisici diversi e di spostarli in seguito. La decisione del guest non è errata, ma non è quella definitiva. È lo stesso confine tra livelli che produce lo steal time lasciato sulle tue vCPU da un vicino rumoroso.

Quale effetto ha quindi questa funzionalità su un tenant VPS? In due casi. Nei piani in cui la topologia è reale anziché sintetica, ad esempio con core dedicati o istanze più grandi che espongono una topologia passata al guest, lo scheduler del guest prende una decisione relativa a hardware effettivamente esistente. Inoltre, sul kernel dell'host del provider, il posizionamento consapevole della cache dei thread delle tue vCPU è un vantaggio che il provider può sfruttare, non tu. La disposizione della cache varia anche in base all'architettura. Questo è un'ulteriore variabile quando confronti un VPS Arm con un VPS x86.

Misurare il comportamento della cache all'interno di un guest è più difficile che su hardware fisico. perf stat -e cache-misses restituisce <not supported> quando il guest non supporta quell'evento, anche quando l'hypervisor non espone la PMU (performance monitoring unit). Misura invece throughput e latenza della tua applicazione e usa il parametro di debugfs come interruttore tra le due esecuzioni.

Verificare se il kernel dispone di CONFIG_SCHED_CACHE

uname -r
grep -E '^(CONFIG_SCHED_CACHE=|# CONFIG_SCHED_CACHE is not set)' /boot/config-$(uname -r) || echo 'not set in this build'
sudo ls /sys/kernel/debug/sched/llc_balancing/

CONFIG_SCHED_CACHE=y indica che il kernel è stato compilato con questa opzione. Una riga # CONFIG_SCHED_CACHE is not set indica che l'opzione esiste in quella versione, ma la distribuzione l'ha disabilitata. Se non è presente alcuna riga corrispondente in un file di configurazione disponibile, l'opzione non è inclusa in quella configurazione; prima di concludere che il kernel sia precedente all'introduzione dell'opzione, controllare uname -r e i sorgenti del kernel della distribuzione. Alcune immagini cloud minimali non includono alcun file /boot/config-*. In questo caso leggere invece zcat /proc/config.gz, che funziona solo se il kernel è stato compilato con CONFIG_IKCONFIG_PROC.

La riga ls stampa i parametri regolabili (enabled, aggr_tolerance e gli altri) quando la funzionalità è inclusa nel kernel. Se restituisce No such file or directory mentre CONFIG_SCHED_CACHE=y, montare prima debugfs con sudo mount -t debugfs none /sys/kernel/debug.

Se uname -r mostra un kernel 7.2, controllare anche la versione correttiva. CVE-2026-98866, pubblicata il 18 October 2026, è una vulnerabilità use-after-free nel codice di scheduling cache aware. Il record CVE del kernel indica come vulnerabili le versioni 7.2 precedenti a 7.2.10; la correzione è inclusa in 7.2.10 e 7.3. Una distribuzione può effettuare il backport della correzione in una build con un numero di versione precedente. L'avviso di sicurezza della distribuzione è quindi il riferimento definitivo.

Per confrontare il carico di lavoro con la funzionalità attiva e disattivata, registrare prima il valore corrente, perché sarà necessario ripristinarlo:

sudo cat /sys/kernel/debug/sched/llc_balancing/enabled
sudo sh -c 'echo 0 > /sys/kernel/debug/sched/llc_balancing/enabled'

Eseguire il benchmark, riscrivere il valore annotato e rieseguire il test. Impostare aggr_tolerance su 0 impedisce l'idoneità all'aggregazione, ma lascia attivo il conteggio. Non è quindi lo stesso interruttore e non evita il codice di accounting vulnerabile in un kernel non corretto. Le modifiche scritte in debugfs non persistono dopo un riavvio, come richiesto durante i test.

Quando una distribuzione includerà il kernel 7.2

Il kernel mainline non è quello avviato dal tuo VPS. La versione indicata in uname -r proviene dalla tua distribuzione, e ogni distribuzione segue un percorso diverso dal rilascio mainline al server.

Fedora aggiorna le proprie versioni stabili ai nuovi kernel mainline durante il periodo di supporto. In questo caso, quindi, sudo dnf upgrade --refresh seguito da un riavvio è l'intero processo. Questa cadenza fa parte delle caratteristiche che scegli quando esegui Fedora Server su un VPS.

Ubuntu rilascia un nuovo kernel con ogni versione semestrale, quindi lo rende disponibile nella precedente versione a supporto a lungo termine (LTS) tramite lo stack HWE (hardware enablement). Al 29 ottobre 2026, la tabella HWE di Canonical indica la versione 6.8 di aprile 2024 come kernel GA di Ubuntu 24.04 LTS. Lo stack HWE di 24.04 è passato alla versione 6.17 a febbraio 2026 e alla versione 7.0 ad agosto 2026; questo kernel HWE 7.0 è indicato come supportato fino ad aprile 2029. Quindi, installando oggi lo stack HWE di 24.04, ottieni la versione 7.0, precedente a CONFIG_SCHED_CACHE. Il passaggio è rapido: la versione 7.0 è stata rilasciata in Ubuntu 26.04 LTS ad aprile 2026 ed è arrivata nello stack HWE di 24.04 ad agosto 2026, quattro mesi dopo. La versione 7.2, però, non segue questo percorso. Il 1 settembre 2026 il team kernel di Canonical ha annunciato che Ubuntu 26.10 avrebbe puntato a Linux 7.3 invece che 7.2; Ubuntu 26.10, rilasciato il 15 ottobre 2026, include la versione 7.3. Le immagini di rilascio usano una build 7.3 basata su 7.3-rc6, perché la versione finale 7.3 è arrivata dopo il rilascio. Ubuntu ha incluso anche la versione 7.2 durante lo sviluppo di 26.10: l'archivio registra l'accettazione di linux 7.2.0-5.5 in stonking-proposed il 28 agosto 2026. La versione 7.3 è costruita sulla versione 7.2 e, una volta installata, grep qui sopra indica se la build di Ubuntu abilita l'opzione.

apt-cache policy linux-generic-hwe-24.04
sudo apt install --install-recommends linux-generic-hwe-24.04

Debian stable mantiene un solo kernel per tutta la durata della versione e offre kernel più recenti tramite backport, che devi abilitare per ogni pacchetto. Al 29 ottobre 2026, trixie-backports elenca linux-image-amd64 versione 7.2.11-1~bpo13+1:

echo 'deb http://deb.debian.org/debian trixie-backports main' | sudo tee /etc/apt/sources.list.d/backports.list
sudo apt update
sudo apt install -t trixie-backports linux-image-amd64

Dopo una di queste procedure, riavvia e verifica con uname -r e grep qui sopra. Un nuovo kernel non può essere caricato dinamicamente: il live patching del kernel su un VPS sostituisce il codice di singole funzioni nel kernel in esecuzione, invece di installare una versione completa e nuova del kernel. Lo scheduling consapevole della cache aggiunge campi a mm_struct, quindi per ottenere la funzionalità tramite un aggiornamento del kernel della distribuzione devi avviare quel kernel.

Seguono due attività pratiche. Mantieni avviabile il kernel precedente finché quello nuovo non ha gestito il tuo carico per un periodo sufficiente. A questo serve impostare quale kernel viene avviato su un VPS. Inoltre, controlla /boot, perché la partizione di boot di un VPS di piccole dimensioni può riempirsi dopo pochi aggiornamenti del kernel, come descritto in rimuovere i vecchi kernel su Ubuntu.

Resta un ultimo aspetto realistico relativo alla responsabilità. Su un VPS KVM, il kernel guest è sotto il tuo controllo: lo scegli, lo avvii e puoi ripristinarne una versione precedente. Il kernel host appartiene al provider e nessuna impostazione all'interno del guest modifica lo scheduler eseguito dall'hypervisor. Quindi una nota di rilascio relativa alla distribuzione dei processi dello scheduler racconta solo metà della situazione per un tenant. La metà che controlli riguarda il guest.

Fonti utilizzate per questa pagina

Per la versione precedente, vedere le novità del kernel Linux 7.1. Per informazioni sull'origine della numerazione delle versioni, vedere la cronologia del kernel Linux.

FAQ

La pianificazione consapevole della cache in Linux 7.2 rende più veloce una VPS?

Di norma, non da sola. La funzionalità si attiva soltanto quando un nodo NUMA segnala più di una cache di ultimo livello, mentre un tipico guest KVM non espone questa topologia; di conseguenza, il codice non viene mai eseguito. Quando la funzionalità si attiva, il guest viene comunque pianificato due volte: il kernel guest sceglie una vCPU e il kernel dell'host decide su quale core fisico eseguire il thread di quella vCPU. Pertanto, l'host può annullare la decisione sulla cache presa dal guest. Esegui lscpu --caches e controlla i file index*/level e shared_cpu_list mostrati sopra. Una sola LLC condivisa da tutte le vCPU non lascia nulla da organizzare alla funzionalità.

Come verifico se il mio kernel include CONFIG_SCHED_CACHE?

Esegui grep -E '^(CONFIG_SCHED_CACHE=|# CONFIG_SCHED_CACHE is not set)' /boot/config-$(uname -r). CONFIG_SCHED_CACHE=y indica che l'opzione è compilata nel kernel, mentre # CONFIG_SCHED_CACHE is not set indica che la distribuzione l'ha disabilitata. Se non è presente alcuna riga corrispondente in un file di configurazione disponibile, l'opzione non è inclusa in quella configurazione; controlla la versione del kernel e il sorgente della distribuzione prima di concludere che sia precedente all'introduzione dell'opzione. Se l'immagine non contiene il file /boot/config-*, prova zcat /proc/config.gz, che esiste soltanto nei kernel compilati con CONFIG_IKCONFIG_PROC. Puoi confermare la situazione a runtime con sudo ls /sys/kernel/debug/sched/llc_balancing/, che elenca i parametri regolabili quando la funzionalità è presente.

Come disattivo la pianificazione consapevole della cache senza riavviare?

Scrivi 0 nel relativo switch semplice: sudo sh -c 'echo 0 > /sys/kernel/debug/sched/llc_balancing/enabled'. In questo modo disattivi la funzionalità a runtime e ottieni un interruttore A/B pulito per un benchmark. Leggi prima il valore corrente con sudo cat /sys/kernel/debug/sched/llc_balancing/enabled e ripristinalo dopo il test, perché i valori predefiniti variano tra le diverse build. Impostare aggr_tolerance su 0 impedisce l'idoneità all'aggregazione, ma lascia attive le callback di contabilizzazione; non disattiva la funzionalità e non evita l'esecuzione del codice di contabilizzazione vulnerabile su un kernel non corretto. Nessun valore scritto in debugfs sopravvive a un riavvio. Se cat restituisce No such file or directory e debugfs è montato, controlla la configurazione del kernel e quali parametri regolabili fornisce quella versione.

Quando Ubuntu o Debian distribuiranno un kernel basato sulla versione 7.2?

Fedora aggiorna le release stabili a nuovi kernel mainline tramite i normali aggiornamenti del kernel e un riavvio. Ubuntu distribuisce nuovi kernel con ogni release semestrale e li rende disponibili anche per la LTS precedente tramite lo stack HWE. Nella tabella HWE di Canonical, per la versione 7.0 questo passaggio ha richiesto quattro mesi: da Ubuntu 26.04, nell'aprile 2026, allo stack HWE di 24.04, nell'agosto 2026; inoltre, il kernel GA di 24.04 è ancora la versione 6.8. Ubuntu ha incluso la versione 7.2 durante lo sviluppo di 26.10, compreso 7.2.0-5.5 accettato in stonking-proposed il 28 agosto 2026. Ubuntu 26.10, rilasciata il 15 ottobre 2026, distribuisce invece la versione 7.3, che include la modifica allo scheduler. Debian stable mantiene un kernel per l'intera release e offre versioni più recenti tramite trixie-backports, che si installano per pacchetto con apt install -t trixie-backports linux-image-amd64. Al 29 ottobre 2026, quel pacchetto è basato sulla versione 7.2.11.

Questo articolo ti è stato utile?

#linux-kernel#scheduler#releases#performance#vps