Aggiornamento, 11 ottobre 2026, 16:30: nel frattempo ho installato il BIOS 1.30. Non sistema lo scarto. tscsync allinea ancora i core, ma in due boot con la sincronizzazione il kernel ha abbandonato il TSC comunque, tramite il watchdog del clocksource e non tramite il controllo dei warp: BIOS 1.30: la sincronizzazione regge, il TSC se ne va lo stesso. Con
tsc=nowatchdogaggiunto il TSC ha tenuto, e cinque minuti misurati contro l’orologio in tempo reale non hanno trovato né warp né deriva: tsc=nowatchdog: cinque minuti, nessun warp. Un boot non è una serie di boot, per questo lo chiamo tiene, non risolto.
Ogni boot, lo stesso avviso
Questo stava nel log del kernel del mio ThinkPad E595 a ogni singolo boot:
TSC synchronization [CPU#0 -> CPU#2]:
Measured 6601281288 cycles TSC warp between CPUs, turning off TSC clock.
tsc: Marking TSC unstable due to check_tsc_sync_source failed
clocksource: Switched to clocksource hpet
Niente è andato in crash. Niente è comparso sul desktop. La macchina ha fatto girare in silenzio tutto il suo orologio su un timer più lento dal momento del boot, e avrebbe continuato così per sempre se non stessi leggendo il journal per tutt’altro.
Il Time Stamp Counter (TSC) è un contatore dentro ogni core della CPU che avanza a ritmo fisso. Leggerlo è una sola istruzione. Linux lo usa come orologio principale, ma solo se tutti i core concordano sul conteggio1. Se un core è indietro, il kernel non può fidarsi e ripiega sull’High Precision Event Timer (HPET), un dispositivo timer separato. L’autore di tscsync ha misurato una lettura dell’orologio a circa 1,2 µs sull’HPET contro decine di nanosecondi sul TSC, e il kernel e il desktop leggono l’orologio decine di migliaia di volte al secondo1. È latenza e batteria, pagate a ogni boot, per niente.
Quindi di quanto era indietro il core? Più di tre secondi. Su un portatile a 2,1 GHz sono 6,6 miliardi di cicli.
Cosa consegna il firmware
Il messaggio nomina la CPU 0 e la CPU 2, ma il guasto non è la CPU 2. Misurato da tscsync dal boot loader, e dal kernel una volta partito, il quadro è sempre lo stesso:
| Core | Scarto dalla CPU 0 | Cosa significa |
|---|---|---|
| CPU 0, il processore di boot (BSP) | 0 | il riferimento, e quello fuori posto |
| CPU da 1 a 7, gli altri core (AP) | circa da +6,2 a +6,8 miliardi di cicli | concordano tra loro entro 32 cicli |
| Distacco a 2.096 MHz | da 2,9 a 3,3 secondi | il processore di boot è indietro, a ogni boot |
Sette core concordano. Uno è in ritardo di tre secondi. Il firmware avvia il processore di boot, ci fa il suo lavoro, e passa il controllo al boot loader senza mai rimettere quel contatore in linea con gli altri.
Perché Linux non può semplicemente sistemarlo? Sulle CPU Intel c’è un registro, IA32_TSC_ADJUST, che permette al kernel di spostare il contatore di un core, e il codice di sincronizzazione del kernel lo usa quando c’è2. Le CPU AMD Zen non ce l’hanno. Senza di esso niente in Linux può riparare lo scarto, e il tentativo nel kernel di scrivere direttamente i contatori (tsc=directsync) è stato respinto upstream come inaffidabile3.
Così il kernel fa l’unica cosa onesta rimasta. Misura, trova il tempo che va all’indietro tra due core, stampa l’avviso e smette di usare il TSC2.
Quaranta boot, quaranta warp
Un boot è un aneddoto. Il journal di questa macchina risale al 30 maggio 2026, quindi l’ho interrogato.
| Boot | Warp, cicli | Warp a 2.096 MHz | |
|---|---|---|---|
| Dal 30 maggio all'11 ottobre 2026 | 40 su 40 | da 6,16 a 9,88 miliardi | da 2,94 a 4,72 s |
| Mediana | 6,57 miliardi | 3,14 s | |
| Dopo uno spegnimento completo di circa 27 s | 1 | 6,60 miliardi | 3,15 s |
| Con tscsync in modalità sync, BIOS 1.28 | 1 | nessuno registrato | TSC mantenuto |
| BIOS 1.30, tscsync spento | 1 | 6,13 miliardi | 2,92 s |
| BIOS 1.30, tscsync in modalità sync | 2 | nessuno registrato | TSC abbandonato dal watchdog, vedi sotto |
BIOS 1.30, modalità sync e tsc=nowatchdog | 1 | nessuno registrato | TSC mantenuto |
Ogni boot. Avvio a freddo, riavvio, dopo uno spegnimento abbastanza lungo da aspettarsi che qualunque residuo sia sparito. L’entità varia, il che torna con quanto ha trovato l’autore di tscsync su un Lenovo Legion: lì il warp cresce quasi esattamente con il tempo che la macchina passa nel firmware prima che parta il boot loader3. Un boot che resta più a lungo sul logo esce più indietro.
La soluzione allettante è tsc=reliable sulla riga di comando del kernel, che dice a Linux di smettere di controllare. Non farlo. I core sono davvero a tre secondi di distanza, e spegnere il controllo non cambia la cosa; lascia solo che il kernel usi un orologio che salta all’indietro quando un task passa da un core all’altro. Il README di tscsync dice lo stesso, e nomina gli scatti di audio e video che seguono1.
Posso chiedere perché esce ancora così?
Non chiedo chi. Chiedo cosa, nel processo di Lenovo, ha permesso di far uscire un BIOS che lascia un core tre secondi indietro a ogni boot.
La risposta è nelle note di progetto di tscsync, e non è lusinghiera. Il Fisher-Price OS (Windows) scrive da sé i TSC al boot3. Un portatile validato solo su quello passa, perché il sistema operativo rimette in ordine in silenzio dopo il firmware. Linux tiene acceso il suo controllo di sicurezza e riporta quello che ha ricevuto, ed è esattamente per questo che il guasto compare lì e da nessun’altra parte.
La parte imbarazzante è che, a quanto si legge, questo è già stato sistemato in passato. Gli utenti riportano che Lenovo ha corretto la stessa classe di bug con un aggiornamento del BIOS sui ThinkPad A485, T14s Gen 1 AMD ed E4954. L’E495 è il fratello da 14 pollici di questa macchina, e condividono un solo BIOS: il readme di Lenovo per il pacchetto li elenca entrambi5.
Il mio E595 era alla 1.28 e andava in warp a ogni boot. Da allora Lenovo ha pubblicato la 1.29 e la 1.30, e nessuno dei due elenchi di modifiche dice una parola sul TSC; la 1.30 corregge «system randomly freeze since BIOS V1.27» e alcuni problemi di sicurezza5. Così ho messo la 1.30 e ho misurato di nuovo. Il primo boot, con tscsync spento, ha registrato un warp di 6.126.446.316 cicli: 2,92 secondi, CPU#0 -> CPU#2, come sempre. La 1.30 non lo sistema. I due modelli condividono un solo BIOS, quindi se la segnalazione sull’E495 fosse giusta anche questa macchina sarebbe sistemata. La segnalazione non nomina alcuna versione del BIOS e non collega alcun log4.
Lenovo tornerà su un portatile del 2019 per un guasto che il sistema operativo su cui fa i test le nasconde? No.
tscsync, prima misurato
tscsync è un piccolo programma UEFI che parte da GRUB o da systemd-boot appena prima di Linux. Chiede a ogni core il suo TSC tramite i servizi multiprocessore del firmware stesso, calcola lo scarto di ogni core dal processore di boot, sposta in avanti i contatori in ritardo finché non concordano, poi verifica il risultato con un test modellato sul controllo dei warp del kernel1. Non scrive mai su flash, NVRAM o impostazioni del firmware; i contatori che modifica si azzerano allo spegnimento1.
È parecchio da affidare a un boot loader, per questo ho letto prima il codice, al commit 230eaa9, prima di compilarlo. L’installazione è stata poi fatta come chiede il progetto:
| Passo | Comando | Cosa è tornato |
|---|---|---|
| Build | make | binari per GRUB e systemd-boot |
| Installazione, sola lettura | sudo scripts/install.sh | modalità measure, niente scritto nei contatori |
| Spegni, avvia, guarda | tscsync-status | CPU 0 2.964 ms dietro a tutti e 7 gli AP, gli AP concordi entro i microsecondi |
| Attivazione | sudo scripts/set-mode.sh sync | ha effetto al boot successivo |
La modalità measure è la parte da copiare in qualunque strumento del genere. Ti mostra il guasto sul tuo hardware prima di avere il permesso di cambiare qualcosa, e una protezione contro i blocchi la spegne se un boot non arriva mai a Linux1.
Il primo boot in modalità sync, direttamente da tscsync-status:
survey (read-only):
cpu 1 apic 1: offset 6815086011 rtt 126 BAD
...
cpu 7 apic 7: offset 6815086010 rtt 378 BAD
0 ok, 7 not ok
moving BSP forward by ~6815086010 cycles to match cpu 7:
bsp vs cpu 7 apic 0: before 6815086001 after 3 rtt 357 iter 3 warps bsp/ap 0/0 OK
AP pass (corrects any AP still off):
7 ok, 0 not ok
total 121 ms
E il kernel, un secondo dopo:
clocksource: Switched to clocksource tsc-early
tsc: Refined TSC clocksource calibration: 2096.066 MHz
clocksource: Switched to clocksource tsc
Nessuna riga di warp. Nessun «unstable». /sys/devices/system/clocksource/clocksource0/current_clocksource dice tsc. 121 ms di boot per avere l’orologio che l’hardware avrebbe dovuto avere fin dall’inizio. Questo era sul BIOS 1.28. La 1.30 non è stata altrettanto pulita.
I 21 nanosecondi che Linux ha scavalcato
C’è una riga in quel report che sembra peggio di quanto sia, e vale la pena spiegarla invece di nasconderla. La verifica finale di tscsync ha segnalato un core:
cpu 7 apic 7: offset 45 rtt 357 warps bsp/ap 0/0 BAD
6 ok, 1 not ok
RESULT: some APs out of sync (Linux will fall back to HPET)
45 cicli sono circa 21 nanosecondi. tscsync punta a una concordanza entro circa 10 cicli1, quindi secondo il suo stesso obiettivo la CPU 7 ha mancato, e lo ha detto. Poi Linux è partito e non è ripiegato affatto sull’HPET.
I due controlli fanno domande diverse:
| Verdetto di tscsync sullo scarto | Test dei warp del kernel | |
|---|---|---|
| Domanda | quanto sono distanti i contatori? | il tempo va mai all’indietro tra i core? |
| Metodo | stima da un andata e ritorno cronometrato | i core leggono a turno e confrontano con l’ultima lettura2 |
| Soglia | circa 10 cicli | nessuna lettura più bassa della precedente |
| CPU 7 in questo boot | 45 cicli, BAD | nessun warp, TSC mantenuto |
Il warps bsp/ap 0/0 sulla stessa riga è tscsync che esegue il test in stile kernel. Non ne ha visto nessuno. Nemmeno il kernel.
Il progetto sa già che il suo verdetto può essere più severo di quello del kernel. Un IdeaPad nel suo elenco hardware aveva quattro core segnalati tra 28 e 42 cicli che il kernel ha accettato, e dalla 2.1 un andata e ritorno lento viene riportato come UNSURE invece che BAD4. La regola del README per quel caso è quella giusta: decide il controllo del kernel, e se il clocksource è tsc, ha passato1. Un andata e ritorno di 357 cicli non è lento su questa macchina, quindi è uscito BAD. Uno strumento che mostra i suoi calcoli e poi lascia l’ultima parola al kernel è il modo giusto.
BIOS 1.30: la sincronizzazione regge, il TSC se ne va lo stesso
Sulla 1.30 ho rimesso tscsync in modalità sync e ho riavviato due volte. Entrambe le volte ha fatto il suo lavoro. Ha spostato in avanti il processore di boot di circa 6,17 miliardi di cicli, ogni core è uscito entro qualche decina di cicli, e il kernel non ha registrato alcun warp. Entrambe le volte Linux è comunque finito sull’HPET pochi secondi dopo:
tsc: Detected 2095.890 MHz processor
tsc: Refined TSC clocksource calibration: 2096.053 MHz
clocksource: Watchdog remote CPU 5 read timed out
clocksource: Marking clocksource tsc unstable due to frequency skew
clocksource: Watchdog hpet interval: 495136113ns
clocksource: Clocksource tsc interval: 496026671ns
tsc: Marking TSC unstable due to clocksource watchdog
È un controllo diverso. Il test dei warp gira mentre ogni core si avvia e chiede se il tempo va mai all’indietro tra i core. Il watchdog del clocksource continua a girare dopo il boot. Più o meno ogni mezzo secondo confronta di quanto si è mosso il TSC con quanto si è mosso l’HPET, e se non concordano oltre un piccolo margine marca il TSC come instabile6. Una volta marcato, resta marcato fino al boot successivo.
tsc=nowatchdog salta solo il secondo, mentre tsc=reliable li salta entrambi e nasconderebbe un warp vero.| Boot sulla 1.30 | Controllo dei warp | Intervallo HPET | Intervallo TSC | TSC contro HPET |
|---|---|---|---|---|
| Primo boot con sync | passato | 495.426.793 ns | 495.006.210 ns | circa 850 ppm lento |
| Secondo boot con sync | passato | 495.136.113 ns | 496.026.671 ns | circa 1.800 ppm veloce |
Quindi il TSC va alla velocità sbagliata? No. Con la macchina accesa ho cronometrato il TSC contro l’orologio raw del kernel basato sull’HPET per 30 secondi in finestre da 5 secondi. Ogni finestra è uscita a 2.096,062 MHz, circa 4 parti per milione dalla calibrazione del kernel stesso. Un vero guasto di frequenza non oscilla da lento a veloce tra due boot per poi sparire. Qualcosa disturba una finestra da mezzo secondo all’inizio del boot, e la riga remote CPU 5 read timed out subito prima indica un core che per un attimo non risponde. Un firmware che ruba tempo alle CPU ci starebbe. Non l’ho dimostrato.
Due boot sono tutte le prove che ci sono. Non so ancora dire se sia la 1.30, il caso, o qualcosa che la scrittura di tscsync innesca. L’unico boot con sync sulla 1.28 ha mantenuto il TSC e i due sulla 1.30 l’hanno perso, e non basta per dare la colpa al BIOS.
Per questo caso c’è un’opzione del kernel più mirata di tsc=reliable. tsc=nowatchdog spegne il watchdog del clocksource per il TSC e lascia stare il controllo dei warp al boot7. Se tscsync non riuscisse mai a sincronizzare, il kernel prenderebbe comunque il warp e ripiegherebbe sull’HPET. Quello era il test successivo. I numeri, e alcune modifiche suggerite ai report di tscsync, sono sull’issue tracker del progetto8.
tsc=nowatchdog: cinque minuti, nessun warp
Ho aggiunto tsc=nowatchdog e riavviato. tscsync ha spostato in avanti il processore di boot di 6.207.104.421 cicli, il kernel non ha registrato né warp né skew, e current_clocksource diceva tsc. Primo boot sulla 1.30 a mantenerlo.
Questo dimostra solo che era il watchdog ad abbandonare il TSC. Non dimostra che il TSC sia sicuro da usare, e con il watchdog spento nel kernel non lo sorveglia più niente. Così l’ho sorvegliato io.
Il mio controllo di frequenza di prima qui non serviva. Cronometrava il TSC contro CLOCK_MONOTONIC_RAW, che andava bene finché il kernel girava sull’HPET. Sul TSC quell’orologio è costruito dal TSC, quindi il test confronterebbe il contatore con se stesso. Nemmeno l’HPET si può leggere dallo spazio utente, perché il kernel di Fedora è compilato senza CONFIG_HPET_MMAP. L’orologio in tempo reale (RTC) sì. Va con un suo quarzo, e il kernel sveglia un programma a ogni scatto del suo contatore dei secondi9.
Così ho scritto un piccolo controllo, tsccheck. Si lega alla CPU 0 ed esegue quattro test ogni 15 secondi:
| Controllo | Come | Che aspetto ha un guasto |
|---|---|---|
| Frequenza | cicli di TSC contati tra gli scatti dei secondi dell’RTC | i MHz che derivano in una direzione |
| Scarto | 3.000 andata e ritorno dalla CPU 0 a ogni core, scarto preso dal più veloce | uno scarto che cresce |
| Warp | in ogni andata e ritorno, un core ha letto meno di un valore già visto? | qualunque cosa sopra zero |
| Clocksource | lettura di current_clocksource | qualunque cosa diversa da tsc |
L’andata e ritorno è il cuore di tutto. La CPU 0 legge il suo contatore e lo passa, l’altro core legge il proprio e lo rimanda, e la CPU 0 legge di nuovo. Se i core concordano, la lettura di mezzo deve cadere tra le altre due:
Il ciclo che lo fa:
for (int i = 0; i < ITERS; i++) {
uint64_t t0 = rdtsc_o(); /* CPU 0 */
atomic_store(&pp.t0, t0);
atomic_store(&pp.seq, 2 * i + 1); /* the other core reads t1 now */
while (atomic_load(&pp.seq) != 2 * i + 2)
;
uint64_t t2 = rdtsc_o(); /* CPU 0 again */
uint64_t t1 = atomic_load(&pp.t1);
if (t1 < t0 || t2 < t1)
r.warps++; /* time went backwards */
if (i > 100 && t2 - t0 < r.rtt) {
r.rtt = t2 - t0;
r.offset = (int64_t)(t1 - (t0 + (t2 - t0) / 2));
}
}
Tutto il programma è C semplice per Linux x86-64, senza niente di legato a tscsync o a questo portatile. Serve root per /dev/rtc0, e il terzo argomento è il valore del tuo kernel da journalctl -k -b | grep 'Refined TSC':
gcc -O2 -Wall -pthread -o tsccheck tsccheck.c
sudo ./tsccheck 15 20 2096.073
SHA-256 02eba1966a0097196acd5dfdcad9c4b315cafc1854c60f34c5b56080e6c38408.
Venti campioni in cinque minuti, subito dopo il boot:
| Misura | Risultato |
|---|---|
| Clocksource | tsc in tutti i 20 campioni, nessun messaggio del kernel |
| Warp | 0 in circa 420.000 andata e ritorno |
| Scarto peggiore dalla CPU 0 | 85 cicli, circa 41 ns, nessuna tendenza |
| Frequenza su tutta la prova | 2.096,027 MHz, tra 2.096,022 e 2.096,031 dal primo minuto in poi |
| Frequenza per finestra da 15 secondi | da 2.095,943 a 2.096,104 MHz |
Le finestre sembrano peggio di quanto siano. Uno scatto dell’RTC in ritardo rende una finestra lunga e la successiva corta, quindi gli errori arrivano a coppie che si annullano: 61 parti per milione (ppm) lento a 30 secondi, 15 ppm veloce a 60. La deriva non si annulla da sola. Il valore su tutta la prova si è mosso appena.
Il valore su tutta la prova sta 22 ppm sotto i 2.096,073 MHz del kernel per tutti i cinque minuti. È la differenza tra due quarzi, ed è rimasta ferma. chrony, che regola l’orologio contro i time server su internet, lo dava lento di 16-19 ppm10. Stessa direzione, stessa entità.
Gli scarti saltano tra gli stessi pochi valori, 10, 21 e 33 cicli da una parte o dall’altra, senza nessun core che si allontana. È rumore di un andata e ritorno di circa 550 cicli. La verifica di tscsync ne chiamerebbe comunque alcuni BAD. Il kernel no.
Il TSC ha tenuto? Sì, su ogni misura che avevo. Cinque minuti dopo un boot non sono comunque una serie di boot. Il prossimo passo è lo stesso controllo dopo un lungo uptime, e di nuovo su qualche altro riavvio.
La correzione va nel firmware
tscsync non dovrebbe esistere. Lo dice il suo stesso README: i produttori di firmware sono liberi di prendere l’approccio e il codice, «which is where this should be fixed»1. Lenovo ha il sorgente. L’autore di tscsync aveva solo quello che il suo portatile gli diceva, e 80 boot di log1.
È questo che resta. La correzione ha richiesto che un estraneo all’azienda misurasse, diagnosticasse e aggirasse il problema, mentre l’azienda che ha venduto l’hardware lo validava sull’unico sistema operativo che nasconde il guasto. Una macchina che non puoi riparare perché il suo firmware è chiuso non è davvero tua, è in prestito con delle condizioni. Un firmware aperto con aggiornamenti firmati avrebbe permesso di sistemarlo una volta, come si deve, a chiunque avesse avuto voglia di guardarci.
Nel frattempo, ottimo lavoro dall’autore di tscsync. Prima la modalità measure, una protezione contro i blocchi, i numeri in chiaro e un verdetto onesto anche quando non è d’accordo con il kernel. È così che vanno costruiti gli strumenti di basso livello.
Ogni host KVM con lo stesso firmware
Su un portatile questo costa un po’ di latenza e un po’ di batteria. Su un hypervisor lo paga anche ogni guest, e niente di quello che segue dipende da Proxmox. Sta tutto nel codice KVM del kernel Linux, quindi è uguale su qualunque host costruito su KVM, qualunque cosa ci sia sopra: Proxmox VE, oVirt, OpenStack, o QEMU e libvirt nudi e crudi11.
Cosa fa KVM quando l’host perde il TSC
KVM dà ai guest un orologio stabile solo quando l’host stesso gira sul TSC. Nel sorgente del kernel il master clock, un unico riferimento di tempo condiviso da ogni vCPU di una VM, si accende solo se host_tsc_clocksource è vero12. Scendi sull’HPET e si spegne, e diverse cose cambiano insieme:
| Host sul TSC | Host sull’HPET, TSC marcato instabile | |
|---|---|---|
| Master clock di KVM12 | acceso | spento |
| Una vCPU passa a un altro core12 | niente da aggiornare | un aggiornamento dell’orologio forzato su ogni vCPU di quella VM, fino a 10 al secondo |
| Lo scarto del TSC del guest12 | lasciato stare | riscritto a ogni spostamento, e messo in modalità di recupero |
PVCLOCK_TSC_STABLE_BIT ai guest12 | impostato | non impostato |
clock_gettime() nel guest13 | letto nello spazio utente | una system call, decisa una volta sola al boot del guest |
| Letture dell’orologio del guest tra le vCPU14 | indipendenti | ogni lettura confrontata con un unico valore globale condiviso |
L’ultima riga è quella che scala male. Senza lo stable bit, il kernel del guest non può fidarsi che l’orologio di ogni vCPU concordi con gli altri, quindi ogni lettura viene confrontata con «last_value, a global accumulator» e sostituita con un compare-and-exchange atomico se è più recente14. Ogni vCPU del guest scrive su quell’unico valore. Più vCPU leggono l’orologio, più fanno la coda lì.
Niente di tutto questo compare come errore. Il clocksource del guest dice ancora kvm-clock, e niente nel guest ti dirà perché è diventato più lento.
Quanto costa, misurato
L’ho misurato su questo portatile invece di lasciarlo come teoria. Il clocksource dell’host si può cambiare mentre gira, e questo spegne il master clock di KVM proprio come fa il ripiego al boot. Un guest usa e getta ha avviato il kernel dell’host con 4 vCPU e un initramfs minuscolo il cui unico programma cronometra clock_gettime(). Due prove per modalità, prima l’host, poi il guest:
clock_gettime(), media di due prove per modalità. L’host diventa da 61 a 73 volte più lento sull’HPET; il guest circa 7 volte con una vCPU e 8 con tutte e quattro. I pannelli usano scale diverse, perché le barre HPET dell’host appiattirebbero quelle del guest.Il guest non paga direttamente il prezzo dell’HPET, perché sotto kvm-clock legge ancora il TSC. Quello che perde è la lettura nello spazio utente e l’indipendenza tra le vCPU, e già solo questo è sette volte più lento. Con tutte e quattro le vCPU che leggono insieme il costo sale ancora, ed è quel valore globale condiviso al lavoro. Un guest con 32 o 64 vCPU ci fa più coda. Non l’ho misurato.
Mettiamoci un numero. Un guest che legge l’orologio un milione di volte al secondo su una vCPU ci spende il 2,8% di quella vCPU su un host sano, e il 19% su questo. Database, la Java Virtual Machine (JVM) e qualunque altra cosa che mette il timestamp al proprio lavoro leggono l’orologio parecchio.
Questa prova inoltre lo sottostima. Cambiare clocksource a mano spegne il master clock ma non marca il TSC come instabile, quindi le riscritture dello scarto nella tabella sopra non sono mai partite. Il ripiego al boot su questo E595 lo marca instabile, e un host in quello stato le paga entrambe.
clockbench.c, il benchmark, da eseguire sull'host o come init di un guestControllare un host, e i limiti
Ho spiegato perché gli orologi dei guest sono fragili fin dall’inizio nell’articolo su ptp_kvm; questo è lo stesso problema che arriva da sotto. Controlla l’host, non il guest:
journalctl -k -b | grep -iE 'TSC warp|TSC unstable'
cat /sys/devices/system/clocksource/clocksource0/current_clocksource
tscsync parte da GRUB o da systemd-boot1, il che copre la maggior parte degli host KVM. Proxmox VE usa GRUB, oppure systemd-boot su un’installazione UEFI con ZFS come root e Secure Boot spento15. Sii però onesto sui limiti prima che si avvicini a un nodo di produzione.
| Limite | Cosa farci |
|---|---|
| Solo AMD Zen e Hygon1 | gli host Intel con TSC_ADJUST li sistema già il kernel |
| Ogni macchina nel suo elenco hardware è un portatile4 | considera un server come non testato e segnalalo |
| La modalità sync rifiuta l’hardware fuori elenco a meno che tu non lo accetti esplicitamente1 | leggi il perché prima di forzarla |
| Un primo boot con sync può bloccarsi | prima la modalità measure, console out-of-band aperta, un nodo alla volta |
| Un aggiornamento del BIOS potrebbe sistemare il guasto | rimettilo in measure dopo e controlla1 |
| Una sincronizzazione pulita può comunque perdere il TSC per colpa del watchdog | controlla current_clocksource dopo ogni boot; tsc=nowatchdog se la causa è il watchdog, poi misuralo tu |
Un guasto del firmware che costa a un portatile un po’ di batteria costa a un hypervisor una fetta di ogni guest che fa girare, ogni secondo in cui è acceso, e chi possiede i guest non ha modo di vederlo. È questo il motivo per controllare current_clocksource su ogni host che gestisci, chiunque l’abbia fatto.
tscsync README — cosa fa, il costo di lettura dell’orologio con l’HPET, perché
tsc=reliablenon è una soluzione, il modello di sicurezza e la regolaUNSURE. ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎Linux kernel — arch/x86/kernel/tsc_sync.c — la gestione di
TSC_ADJUST, il test dei warp e il messaggio «Measured %Ld cycles TSC warp between CPUs, turning off TSC clock.». ↩︎ ↩︎ ↩︎tscsync — docs/DESIGN.md — AMD Zen non ha
IA32_TSC_ADJUST,tsc=directsyncrespinto upstream, Windows scrive da sé i TSC al boot, e il warp che cresce con il tempo passato nel firmware sul Legion Pro 5. ↩︎ ↩︎ ↩︎tscsync — docs/HARDWARE.md — macchine testate, i core dell’IdeaPad 5 accettati tra -28 e -42 cicli, e le correzioni del BIOS segnalate su A485, E495 e T14s Gen 1. ↩︎ ↩︎ ↩︎ ↩︎
Lenovo — BIOS Update Utility readme, ThinkPad E495/E595, version 1.30 — entrambi i modelli in un solo pacchetto, la cronologia delle versioni fino alla 1.30 (14 maggio 2024), e il suo elenco di modifiche. ↩︎ ↩︎
Linux kernel — kernel/time/clocksource.c — il watchdog del clocksource, il suo confronto degli intervalli e il messaggio «Marking clocksource %s unstable due to frequency skew». ↩︎
Linux kernel — kernel-parameters —
tsc=reliabledisattiva la verifica a runtime e i controlli di stabilità al boot;tsc=nowatchdogdisattiva solo il watchdog del clocksource. ↩︎tscsync issue #1 — Lenovo ThinkPad E595 — i report per 1.28 e 1.30, l’analisi del watchdog e le modifiche suggerite. ↩︎
Linux kernel — Real Time Clock (RTC) Drivers for Linux — «The clock can also be set to generate an interrupt upon every clock update, thus generating a 1Hz signal», letto tramite
/dev/rtc. ↩︎chrony — chronyc manual —
tracking: «The ‘frequency’ is the rate by which the system’s clock would be wrong if chronyd was not correcting it.» ↩︎KVM — Management Tools — Proxmox VE, oVirt, OpenStack e gli strumenti basati su libvirt, tutti per gestire KVM. ↩︎
Linux kernel — arch/x86/kvm/x86.c —
pvclock_update_vm_gtod_copy(): «If the host uses TSC clock, then passthrough TSC as stable to the guest», ePVCLOCK_TSC_STABLE_BITimpostato solo con il master clock. ↩︎ ↩︎ ↩︎ ↩︎ ↩︎Linux kernel — arch/x86/kernel/kvmclock.c — il guest abilita l’orologio in spazio utente
VDSO_CLOCKMODE_PVCLOCKsolo quandoPVCLOCK_TSC_STABLE_BITè impostato. ↩︎Linux kernel — arch/x86/kernel/pvclock.c — senza
PVCLOCK_TSC_STABLE_BIT, ogni lettura viene confrontata con «last_value, a global accumulator» con un compare-and-exchange atomico. ↩︎ ↩︎Proxmox VE — Host Bootloader — GRUB di default, systemd-boot per le installazioni UEFI con root su ZFS e Secure Boot spento. ↩︎