Atualização, 11 de outubro de 2026, 16:30: entretanto instalei a BIOS 1.30. Não corrige o desvio. O tscsync continua a alinhar os núcleos, mas em dois arranques com sincronização o kernel deixou cair o TSC na mesma, pelo watchdog de clocksource e não pela verificação de warp: BIOS 1.30: a sincronização aguenta, o TSC vai-se na mesma. Com tsc=nowatchdog acrescentado, o TSC aguentou, e cinco minutos medidos contra o relógio de tempo real não encontraram warps nem deriva: tsc=nowatchdog: cinco minutos, zero warps. Um arranque não é uma série de arranques, como tal chamo-lhe a aguentar, não resolvido.

Em cada arranque, o mesmo aviso

Isto estava no registo do kernel do meu ThinkPad E595 em todos os arranques, sem exceção:

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

Nada rebentou. Nada apareceu no ambiente de trabalho. A máquina correu calada o relógio todo num chip temporizador mais lento desde o momento em que arrancou, e teria continuado assim para sempre se eu não estivesse a ler o journal por outro motivo.

O Time Stamp Counter (TSC) é um contador dentro de cada núcleo do CPU que avança a um ritmo fixo. Lê-lo é uma única instrução. O Linux usa-o como relógio principal, mas só se todos os núcleos concordarem na contagem1. Se um núcleo estiver atrasado, o kernel não pode confiar nele e recorre ao High Precision Event Timer (HPET), um dispositivo temporizador à parte. O autor do tscsync mediu uma leitura do relógio em cerca de 1,2 µs no HPET contra dezenas de nanossegundos no TSC, e o kernel e o ambiente de trabalho leem o relógio dezenas de milhares de vezes por segundo1. É latência e bateria, pagas em cada arranque, por nada.

Então quão atrasado estava o núcleo? Mais de três segundos. Num portátil a 2,1 GHz isso são 6,6 mil milhões de ciclos.

O que o firmware entrega

A mensagem fala do CPU 0 e do CPU 2, mas a culpa não é do CPU 2. Medido pelo tscsync a partir do gestor de arranque, e pelo kernel quando arranca, o quadro é sempre o mesmo:

NúcleoDesvio em relação ao CPU 0O que quer dizer
CPU 0, o processador de arranque (BSP)0a referência, e o que destoa
CPUs 1 a 7, os outros núcleos (APs)cerca de +6,2 a +6,8 mil milhões de ciclostodos concordam entre si a menos de 32 ciclos
Diferença a 2096 MHz2,9 a 3,3 segundoso processador de arranque está atrasado, em cada arranque

Sete núcleos concordam. Um vem três segundos atrasado. O firmware arranca o processador de arranque, faz o seu trabalho nele, e passa para o gestor de arranque sem nunca pôr aquele contador de volta em linha com os outros.

O TSC do processador de arranque antes e depois do tscsyncAntes: tal como o firmware entregaDepois: tscsync em modo syncCPU 0 (BSP)CPU 1CPU 2CPU 3CPU 4CPU 5CPU 6CPU 7CPU 0 (BSP)CPU 1CPU 2CPU 3CPU 4CPU 5CPU 6CPU 7CPU 0 cerca de 6,8 mil milhões de ciclos (3,25 s) atrásCPUs 1 a 7 concordam a menos de 32 ciclosBSP adiantado, todos os núcleos a menos de 45 ciclosO Linux mantém o clocksource TSC
À esquerda: o que o firmware entrega. Os sete processadores de aplicação concordam a menos de 32 ciclos; o processador de arranque está cerca de 6,8 mil milhões de ciclos atrás deles. À direita: depois de o tscsync adiantar o processador de arranque em UEFI, todos os núcleos ficam a menos de 45 ciclos e a verificação de warp do kernel passa.

Porque é que o Linux não pode simplesmente corrigir isto? Nos CPU Intel há um registo, IA32_TSC_ADJUST, que deixa o kernel dar um toque no contador de um núcleo, e o código de sincronização do kernel usa-o quando existe2. Os CPU AMD Zen não o têm. Sem ele, nada no Linux consegue reparar o desvio, e a tentativa dentro do kernel de escrever os contadores diretamente (tsc=directsync) foi rejeitada a montante por não ser fiável3.

Por isso o kernel faz a única coisa honesta que resta. Mede, encontra o tempo a andar para trás entre dois núcleos, imprime o aviso e deixa de usar o TSC2.

Quarenta arranques, quarenta warps

Um arranque é uma história. O journal desta máquina vai até 30 de maio de 2026, por isso perguntei-lhe.

ArranquesWarp, ciclosWarp a 2096 MHz
30 de maio a 11 de outubro de 202640 de 406,16 a 9,88 mil milhões2,94 a 4,72 s
Mediana6,57 mil milhões3,14 s
Depois de desligar por completo cerca de 27 s16,60 mil milhões3,15 s
Com o tscsync em modo sync, BIOS 1.281nenhum registadoTSC mantido
BIOS 1.30, tscsync desligado16,13 mil milhões2,92 s
BIOS 1.30, tscsync em modo sync2nenhum registadoTSC deixado cair pelo watchdog, ver abaixo
BIOS 1.30, modo sync e tsc=nowatchdog1nenhum registadoTSC mantido

Em todos os arranques. Arranque a frio, reinício, depois de estar desligado tempo suficiente para se esperar que qualquer coisa velha tivesse desaparecido. O valor varia, o que bate com o que o próprio autor do tscsync encontrou num Lenovo Legion: aí, o warp acompanha quase na perfeição o tempo que a máquina passa no firmware antes de o gestor de arranque começar3. Um arranque que fica mais tempo no logótipo sai mais atrasado.

A correção tentadora é tsc=reliable na linha de comandos do kernel, que diz ao Linux para deixar de verificar. Não o faças. Os núcleos estão mesmo três segundos afastados, e desligar a verificação não muda isso; só deixa o kernel usar um relógio que salta para trás quando uma tarefa muda de núcleo. O README do tscsync diz o mesmo, e aponta os soluços de áudio e vídeo que se seguem1.

Posso perguntar porque é que isto ainda é vendido assim?

Não estou a perguntar quem. Estou a perguntar o que é que no processo da Lenovo deixou sair uma BIOS que deixa um núcleo três segundos atrasado em cada arranque.

A resposta está nas notas de desenho do tscsync, e não é lisonjeira. O Fisher-Price OS (Windows) escreve ele próprio os TSC no arranque3. Um portátil validado só nesse sistema passa, porque o sistema operativo arruma discretamente o que o firmware deixou. O Linux mantém a sua verificação de segurança ligada e reporta o que lhe deram, e é exatamente por isso que a falha aparece ali e em mais lado nenhum.

A parte incómoda é que, segundo consta, isto já foi corrigido antes. Há utilizadores que relatam que a Lenovo corrigiu a mesma classe de erro por atualização de BIOS no ThinkPad A485, no T14s Gen 1 AMD e no E4954. O E495 é o irmão de 14 polegadas desta máquina, e partilham uma BIOS: o próprio readme da Lenovo para o pacote lista os dois5.

O meu E595 estava na 1.28 e tinha warp em cada arranque. A Lenovo publicou entretanto a 1.29 e a 1.30, e nenhuma das listas de alterações diz uma palavra sobre o TSC; a 1.30 corrige «system randomly freeze since BIOS V1.27» e alguns problemas de segurança5. Por isso instalei a 1.30 e voltei a medir. O primeiro arranque nela, com o tscsync desligado, registou um warp de 6 126 446 316 ciclos: 2,92 segundos, CPU#0 -> CPU#2, como sempre. A 1.30 não o corrige. Os dois modelos partilham uma BIOS, por isso se o relato do E495 estivesse certo, esta máquina também estaria corrigida. O relato não indica nenhuma versão de BIOS nem aponta registos4.

Vai a Lenovo voltar a um portátil de 2019 por causa de uma falha que o sistema operativo em que testa lhe esconde? Não.

tscsync, primeiro a medir

O tscsync é um pequeno programa UEFI que corre a partir do GRUB ou do systemd-boot mesmo antes do Linux. Pede a cada núcleo o seu TSC através dos próprios serviços multiprocessador do firmware, calcula o desvio de cada núcleo em relação ao processador de arranque, adianta os contadores atrasados até concordarem, e depois verifica o resultado com um teste inspirado na própria verificação de warp do kernel1. Nunca escreve na flash, na NVRAM nem nas definições do firmware; os contadores que altera reiniciam quando a máquina se desliga1.

É muito para entregar a um gestor de arranque, como tal li o código primeiro, no commit 230eaa9, antes de o compilar. A instalação foi depois feita como o projeto pede:

PassoComandoO que veio de volta
Compilarmakebinários para GRUB e systemd-boot
Instalar, só de leiturasudo scripts/install.shmodo measure, nada escrito nos contadores
Desligar, arrancar, vertscsync-statusCPU 0 2964 ms atrás dos 7 APs, os APs a concordar a menos de microssegundos
Ligarsudo scripts/set-mode.sh syncfaz efeito no próximo arranque

O modo measure é a parte que vale a pena copiar para qualquer ferramenta deste género. Mostra-te a falha no teu próprio hardware antes de ter licença para mudar o que quer que seja, e uma proteção contra bloqueios desliga-o se um arranque nunca chegar ao Linux1.

O primeiro arranque em modo sync, tirado diretamente do 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 o kernel, um segundo depois:

clocksource: Switched to clocksource tsc-early
tsc: Refined TSC clocksource calibration: 2096.066 MHz
clocksource: Switched to clocksource tsc

Nenhuma linha de warp. Nenhum «unstable». /sys/devices/system/clocksource/clocksource0/current_clocksource diz tsc. 121 ms de arranque para ter o relógio que o hardware devia ter tido desde o início. Isso foi na BIOS 1.28. A 1.30 não tem sido tão arrumada.

Os 21 nanossegundos que o Linux deixou passar

Há uma linha nesse relatório que parece pior do que é, e vale a pena explicá-la em vez de a esconder. A passagem final de verificação do tscsync assinalou um núcleo:

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 ciclos são cerca de 21 nanossegundos. O tscsync aponta para uma concordância a menos de cerca de 10 ciclos1, por isso, pelo seu próprio objetivo, o CPU 7 falhou, e ele disse-o. Depois o Linux arrancou e não recorreu ao HPET de todo.

As duas verificações fazem perguntas diferentes:

Veredicto de desvio do tscsyncTeste de warp do kernel
Perguntaquão afastados estão os contadores?o tempo alguma vez anda para trás entre núcleos?
Métodoestimativa a partir de uma ida e volta cronometradaos núcleos leem à vez e comparam com a última leitura2
Critériocerca de 10 ciclosnenhuma leitura mais baixa do que a anterior
CPU 7 neste arranque45 ciclos, BADnenhum warp, TSC mantido

O warps bsp/ap 0/0 nessa mesma linha é o tscsync a correr o teste ao estilo do kernel. Não viu nenhum. O kernel também não.

O projeto já sabe que o seu veredicto pode ser mais rigoroso do que o do kernel. Um IdeaPad na sua lista de hardware tinha quatro núcleos assinalados entre 28 e 42 ciclos que o kernel aceitou, e desde a 2.1 uma ida e volta lenta é reportada como UNSURE em vez de BAD4. A regra do README para esse caso é a certa: decide a verificação do próprio kernel, e se o clocksource for tsc, passou1. Uma ida e volta de 357 ciclos não é lenta nesta máquina, por isso saiu BAD. Uma ferramenta que mostra as contas e depois deixa a última palavra ao kernel está do lado certo.

BIOS 1.30: a sincronização aguenta, o TSC vai-se na mesma

Na 1.30 voltei a pôr o tscsync em modo sync e reiniciei duas vezes. Das duas vezes fez o seu trabalho. Adiantou o processador de arranque cerca de 6,17 mil milhões de ciclos, todos os núcleos ficaram a umas poucas dezenas de ciclos, e o kernel não registou warp nenhum. Das duas vezes o Linux acabou na mesma no HPET uns segundos depois:

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

Esta é uma verificação diferente. O teste de warp corre à medida que cada núcleo arranca e pergunta se o tempo alguma vez anda para trás entre núcleos. O watchdog de clocksource continua a correr depois do arranque. Mais ou menos a cada meio segundo compara quanto avançou o TSC com quanto avançou o HPET, e se discordarem por mais de uma pequena margem marca o TSC como instável6. Depois de marcado, fica assim até ao próximo arranque.

Duas verificações do kernel, e que opção de arranque salta qualFirmwareCPU 0 ~3 s atrástscsync, em UEFIadianta o CPU 0O Linux arrancaos núcleos arrancamVerificação de warpuma vez, no arranqueWatchdogcada 0,5 s vs. HPETPor omissãoambas ligadas: TSC perdido na 1.30✓ verificado✓ verificadotsc=nowatchdogeste arranque: TSC mantido✓ verificado✗ saltadotsc=reliabledesaconselhado: esconde um warp real✗ saltado✗ saltado
Duas verificações separadas podem deixar cair o TSC. A verificação de warp corre uma vez, à medida que cada núcleo arranca; é o tscsync que faz esta máquina passá-la. O watchdog continua a comparar com o HPET a cada meio segundo. tsc=nowatchdog salta só a segunda, enquanto tsc=reliable salta as duas e esconderia um warp real.
Arranque na 1.30Verificação de warpIntervalo HPETIntervalo TSCTSC face ao HPET
Primeiro arranque com syncpassou495 426 793 ns495 006 210 nscerca de 850 ppm lento
Segundo arranque com syncpassou495 136 113 ns496 026 671 nscerca de 1800 ppm rápido

Então o TSC está a correr ao ritmo errado? Não. Com a máquina ligada, cronometrei o TSC contra o relógio raw do kernel baseado no HPET durante 30 segundos em janelas de 5 segundos. Todas as janelas deram 2096,062 MHz, cerca de 4 partes por milhão da própria calibração do kernel. Uma falha real de ritmo não salta de lento para rápido entre dois arranques e depois desaparece. Alguma coisa perturba uma janela de meio segundo logo no início do arranque, e a linha remote CPU 5 read timed out mesmo antes aponta para um núcleo que por instantes não responde. Firmware a roubar tempo aos CPU encaixaria. Não o provei.

Dois arranques é toda a prova que há. Ainda não sei dizer se é a 1.30, acaso, ou algo que a escrita do tscsync desencadeia. O único arranque com sync na 1.28 manteve o TSC e os dois na 1.30 perderam-no, e isso não chega para culpar a BIOS.

Há uma opção do kernel mais estreita do que tsc=reliable para este caso. tsc=nowatchdog desliga o watchdog de clocksource para o TSC e deixa em paz a verificação de warp no arranque7. Se o tscsync alguma vez falhasse a sincronização, o kernel apanharia na mesma o warp e recorreria ao HPET. Esse foi o teste seguinte. Os números, e algumas alterações sugeridas aos próprios relatórios do tscsync, estão no gestor de issues do projeto8.

tsc=nowatchdog: cinco minutos, zero warps

Acrescentei tsc=nowatchdog e reiniciei. O tscsync adiantou o processador de arranque 6 207 104 421 ciclos, o kernel não registou warp nem desvio de frequência, e current_clocksource dizia tsc. Primeiro arranque na 1.30 a mantê-lo.

Isso só prova que foi o watchdog que deixou cair o TSC. Não prova que é seguro usar o TSC, e com o watchdog desligado já nada no kernel está a vigiar. Por isso vigiei eu.

A minha verificação de ritmo anterior não servia aqui. Cronometrava o TSC contra CLOCK_MONOTONIC_RAW, o que estava bem enquanto o kernel corria no HPET. No TSC, esse relógio é construído a partir do TSC, por isso o teste compararia o contador consigo próprio. O HPET também não pode ser lido a partir do espaço de utilizador, porque o kernel da Fedora é compilado sem CONFIG_HPET_MMAP. O relógio de tempo real (RTC) pode. Corre com o seu próprio cristal, e o kernel acorda um programa em cada tique do seu contador de segundos9.

Por isso escrevi uma pequena verificação, tsccheck. Fixa-se no CPU 0 e corre quatro testes a cada 15 segundos:

VerificaçãoComoComo se vê uma falha
Ritmociclos do TSC contados entre tiques de segundo do RTCos MHz a derivar para um lado
Desvio3000 idas e voltas do CPU 0 a cada núcleo, desvio tirado da mais rápidaum desvio que cresce
Warpsem cada ida e volta, algum núcleo leu um valor mais baixo do que um já vistoqualquer coisa acima de zero
Clocksourceler current_clocksourcequalquer coisa que não seja tsc

A ida e volta é o cerne. O CPU 0 lê o seu contador e passa-o, o outro núcleo lê o seu e devolve-o, e o CPU 0 lê outra vez. Se os núcleos concordarem, a leitura do meio tem de cair entre as outras duas:

Uma ida e volta entre o CPU 0 e outro núcleoCPU 0CPU 1 a 7, um de cada veztempot0t1t2ponto médiodesviodesvio = t1 − (t0 + t2) / 2da mais rápida de 3000 idas e voltaswarp se t1 < t0 ou t2 < t1tempo a andar para trás: um só já é falha
Uma ida e volta. A leitura do outro núcleo, t1, é comparada com o ponto médio das duas leituras do CPU 0, e a mais rápida de 3000 idas e voltas dá o desvio. Qualquer leitura mais baixa do que uma já vista é um warp, seja qual for o desvio.

O ciclo que o faz:

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));
	}
}

O programa inteiro é C simples para Linux x86-64, sem nada ligado ao tscsync ou a este portátil. Precisa de root para /dev/rtc0, e o terceiro argumento é o valor do teu próprio kernel tirado de journalctl -k -b | grep 'Refined TSC':

gcc -O2 -Wall -pthread -o tsccheck tsccheck.c
sudo ./tsccheck 15 20 2096.073
tsccheck.c, a verificação inteira em 161 linhas tsccheck.c · 4 kB

SHA-256 02eba1966a0097196acd5dfdcad9c4b315cafc1854c60f34c5b56080e6c38408.

Vinte amostras ao longo de cinco minutos, logo a seguir ao arranque:

MedidaResultado
Clocksourcetsc nas 20 amostras, nenhuma mensagem do kernel
Warps0 em cerca de 420 000 idas e voltas
Pior desvio face ao CPU 085 ciclos, cerca de 41 ns, sem tendência
Ritmo na execução toda2096,027 MHz, entre 2096,022 e 2096,031 a partir do primeiro minuto
Ritmo por janela de 15 segundos2095,943 a 2096,104 MHz
Ritmo do TSC por janela de 15 segundos, e na execução toda+20 ppm0 ppm-20 ppm-40 ppm-60 ppm0 s60 s120 s180 s240 s300 svalor do kernel, 2096,073 MHz15 s: janela -11,3 ppm, execução toda -11,3 ppm30 s: janela -61,1 ppm, execução toda -36,2 ppm45 s: janela -23,5 ppm, execução toda -32,0 ppm60 s: janela +15,0 ppm, execução toda -20,2 ppm75 s: janela -21,6 ppm, execução toda -20,5 ppm90 s: janela -21,8 ppm, execução toda -20,7 ppm105 s: janela -19,6 ppm, execução toda -20,6 ppm120 s: janela -50,5 ppm, execução toda -24,3 ppm135 s: janela +5,8 ppm, execução toda -20,9 ppm150 s: janela -20,3 ppm, execução toda -20,9 ppm165 s: janela -23,6 ppm, execução toda -21,1 ppm180 s: janela -13,7 ppm, execução toda -20,5 ppm195 s: janela -29,5 ppm, execução toda -21,2 ppm210 s: janela -22,3 ppm, execução toda -21,3 ppm225 s: janela -20,0 ppm, execução toda -21,2 ppm240 s: janela -24,7 ppm, execução toda -21,4 ppm255 s: janela -19,1 ppm, execução toda -21,3 ppm270 s: janela -22,2 ppm, execução toda -21,3 ppm285 s: janela -62,0 ppm, execução toda -23,5 ppm300 s: janela +9,2 ppm, execução toda -21,9 ppmuma janela de 15 s, 61 ppm lentoexecução toda até aquijanela de 15 segundosexecução toda até aqui
Ritmo contra o RTC, em partes por milhão face ao valor do kernel. As janelas individuais saltam aos pares; o valor da execução toda estabiliza em 21 a 22 ppm lento logo no primeiro minuto e fica aí.

As janelas parecem piores do que são. Um tique do RTC atrasado torna uma janela longa e a seguinte curta, por isso os erros vêm aos pares que se anulam: 61 partes por milhão (ppm) lento aos 30 segundos, 15 ppm rápido aos 60. A deriva não se anula sozinha. O valor da execução toda quase não mexeu.

O valor da execução toda fica 22 ppm abaixo dos 2096,073 MHz do kernel durante os cinco minutos inteiros. É a diferença entre dois cristais, e manteve-se quieta. O chrony, a acertar o relógio contra servidores de tempo da internet, dava-o entre 16 e 19 ppm lento10. Mesma direção, mesmo tamanho.

Os desvios saltitam entre os mesmos poucos valores, 10, 21 e 33 ciclos para cada lado, sem nenhum núcleo a afastar-se. É ruído de uma ida e volta de cerca de 550 ciclos. A verificação do tscsync ainda chamaria BAD a alguns deles. O kernel não.

O TSC aguentou? Sim, em todas as medidas que eu tinha. Cinco minutos depois de um arranque continua a não ser uma série de arranques. A seguir vem a mesma verificação depois de muito tempo ligado, e outra vez ao longo de mais alguns reinícios.

A correção pertence ao firmware

O tscsync não devia precisar de existir. O próprio README o diz: os fabricantes de firmware estão à vontade para usar a abordagem e o código, «which is where this should be fixed»1. A Lenovo tem o código-fonte. O autor do tscsync só tinha o que o portátil lhe dizia, e 80 arranques de registos1.

É isso que fica. A correção precisou de um estranho, de fora da empresa, para medir, diagnosticar e contornar, enquanto a firma que vendeu o hardware o validou contra o único sistema operativo que esconde a falha. Uma máquina que não podes reparar porque o firmware é fechado não é bem tua, está emprestada com condições. Firmware aberto com atualizações assinadas teria deixado isto ser corrigido uma vez, como deve ser, por qualquer pessoa que se importasse o suficiente para ir ver.

Entretanto, bom trabalho do autor do tscsync. Modo measure primeiro, proteção contra bloqueios, os números à vista e um veredicto honesto mesmo quando discorda do kernel. É assim que as ferramentas de baixo nível devem ser feitas.

Todos os hosts KVM com o mesmo firmware

Num portátil isto custa alguma latência e alguma bateria. Num hipervisor cada convidado paga também, e nada do que se segue é culpa do Proxmox. Vive tudo no código KVM do kernel Linux, por isso é igual em qualquer host construído sobre KVM, seja o que for que esteja por cima: Proxmox VE, oVirt, OpenStack, ou QEMU e libvirt simples11.

O que o KVM faz quando o host perde o TSC

O KVM só dá aos convidados um relógio estável quando o próprio host corre no TSC. No código-fonte do kernel, o relógio mestre, uma referência de tempo partilhada por todos os vCPU de uma VM, só é ligado se host_tsc_clocksource for verdadeiro12. Desce para o HPET e desliga-se, e várias coisas mudam de uma vez:

Host no TSCHost no HPET, TSC marcado instável
Relógio mestre do KVM12ligadodesligado
Um vCPU muda para outro núcleo12nada a atualizaruma atualização de relógio forçada em todos os vCPU dessa VM, até 10 por segundo
O desvio do TSC do convidado12deixado em pazreescrito em cada mudança, e posto em modo de recuperação
PVCLOCK_TSC_STABLE_BIT para os convidados12ligadonão ligado
clock_gettime() no convidado13lido no espaço de utilizadoruma chamada ao sistema, decidida uma vez quando o convidado arranca
Leituras do relógio entre vCPU no convidado14independentescada leitura verificada contra um único valor global partilhado

A última linha é a que escala mal. Sem o bit de estabilidade, o kernel do convidado não pode confiar que o relógio de cada vCPU concorda com os outros, por isso cada leitura é comparada com «last_value, a global accumulator» e trocada com um compare-and-exchange atómico se for mais recente14. Todos os vCPU do convidado escrevem nesse único valor. Quantos mais vCPU leem o relógio, mais fazem fila nele.

Nada disto aparece como erro. O clocksource do convidado continua a dizer kvm-clock, e nada no convidado te dirá porque é que ficou mais lento.

Como o clocksource do host chega a um convidado KVMHost no TSCClocksource do host: tscuma instrução para lerrelógio mestre do KVM ligadobit de estabilidade para os convidadosO convidado lê no espaço de utilizadorvDSO, cerca de 28 nsHost no HPETClocksource do host: hpetuma ida ao temporizadorrelógio mestre do KVM desligadosem bit de estabilidade, atualiza a cada mudança de vCPUO convidado faz uma chamada ao sistemaum valor partilhado, cerca de 190 nsO mesmo código do kernel no Proxmox VE, oVirt, OpenStack ou QEMU e libvirt simples
O clocksource do host decide o que cada convidado recebe. No TSC, os convidados leem o relógio no espaço de utilizador. No HPET, o KVM larga o relógio mestre, cada mudança de vCPU força atualizações de relógio, e cada leitura do relógio no convidado passa a ser uma chamada ao sistema verificada contra um valor que todos os vCPU partilham.

Quanto custa, medido

Medi-o neste portátil em vez de o deixar como teoria. O clocksource do host pode ser trocado com a máquina a correr, o que desliga o relógio mestre do KVM tal como o recurso ao HPET no arranque. Um convidado descartável arrancou o próprio kernel do host com 4 vCPU e um initramfs minúsculo cujo único programa cronometra clock_gettime(). Duas execuções de cada maneira, primeiro o host, depois o convidado:

Nanossegundos por leitura do relógio, host no TSC contra host no HPETHostescala de 0 a 2400 nsHost, 1 thread, host no TSC: 24 ns24 nsHost, 1 thread, host no HPET: 1542 ns1542 ns1 threadHost, os 8 núcleos, host no TSC: 29 ns29 nsHost, os 8 núcleos, host no HPET: 1922 ns1922 nsos 8 núcleosConvidado, 4 vCPUescala de 0 a 300 nsConvidado, 4 vCPU, 1 vCPU, host no TSC: 28 ns28 nsConvidado, 4 vCPU, 1 vCPU, host no HPET: 187 ns187 ns1 vCPUConvidado, 4 vCPU, os 4 vCPU, host no TSC: 31 ns31 nsConvidado, 4 vCPU, os 4 vCPU, host no HPET: 244 ns244 nsos 4 vCPUclocksource do host tscclocksource do host hpet
Nanossegundos por chamada a clock_gettime(), média de duas execuções de cada maneira. O host fica 61 a 73 vezes mais lento no HPET; o convidado cerca de 7 vezes com um vCPU e 8 com os quatro. Os painéis usam escalas diferentes, porque as barras HPET do host esmagariam as do convidado.

O convidado não paga diretamente o preço do HPET, porque o kvm-clock continua a ler o TSC por baixo. O que perde é a leitura no espaço de utilizador e a independência entre vCPU, e só isso é sete vezes mais lento. Com os quatro vCPU a ler ao mesmo tempo o custo sobe outra vez, e isso é o tal valor global partilhado a trabalhar. Um convidado com 32 ou 64 vCPU faz mais fila nele. Isso não medi.

Põe-lhe um número. Um convidado que lê o relógio um milhão de vezes por segundo num vCPU gasta 2,8% desse vCPU a fazê-lo num host saudável, e 19% neste. Bases de dados, a Java Virtual Machine (JVM) e tudo o mais que põe carimbos de tempo no seu trabalho leem muito o relógio.

Esta execução também fica aquém. Trocar de clocksource à mão desliga o relógio mestre mas não marca o TSC como instável, por isso as reescritas do desvio da tabela acima nunca correram. O recurso no arranque deste E595 marca-o como instável, e um host nesse estado paga as duas coisas.

clockbench.c, o benchmark, a correr no host ou como init de um convidado clockbench.c · 2 kB

Verificar um host, e os limites

Expliquei porque é que os relógios dos convidados são frágeis à partida no artigo sobre o ptp_kvm; isto é o mesmo problema a chegar por baixo. Verifica o host, não o convidado:

journalctl -k -b | grep -iE 'TSC warp|TSC unstable'
cat /sys/devices/system/clocksource/clocksource0/current_clocksource

O tscsync corre a partir do GRUB ou do systemd-boot1, o que cobre a maioria dos hosts KVM. O Proxmox VE usa GRUB, ou systemd-boot numa instalação UEFI com ZFS como raiz e o Secure Boot desligado15. Mas sê honesto quanto aos limites antes de isto se aproximar de um nó de produção.

LimiteO que fazer
Só AMD Zen e Hygon1os hosts Intel com TSC_ADJUST já são corrigidos pelo kernel
Todas as máquinas da sua lista de hardware são portáteis4trata um servidor como não testado e reporta-o
O modo sync recusa hardware fora da lista, a não ser que optes por ele1lê porquê antes de o forçares
Um primeiro arranque com sync pode bloquearmodo measure primeiro, consola fora de banda aberta, um nó de cada vez
Uma atualização de BIOS pode corrigir a falhavolta a pô-lo em measure depois e verifica1
Uma sincronização limpa pode ainda perder o TSC para o watchdogverifica current_clocksource depois de cada arranque; tsc=nowatchdog se o watchdog for a causa, e depois mede tu mesmo

Uma falha de firmware que custa alguma bateria a um portátil custa a um hipervisor uma fatia de cada convidado que corre, em cada segundo que está ligado, e os donos dos convidados não têm maneira de o ver. É essa a razão para verificar current_clocksource em cada host que geres, seja quem for o fabricante.


  1. tscsync README — o que faz, o custo de ler o relógio no HPET, porque é que tsc=reliable não é solução, o modelo de segurança e a regra do UNSURE. ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎

  2. Linux kernel — arch/x86/kernel/tsc_sync.c — o tratamento do TSC_ADJUST, o teste de warp e a mensagem «Measured %Ld cycles TSC warp between CPUs, turning off TSC clock.». ↩︎ ↩︎ ↩︎

  3. tscsync — docs/DESIGN.md — o AMD Zen não tem IA32_TSC_ADJUST, tsc=directsync rejeitado a montante, o Fisher-Price OS (Windows) escreve ele próprio os TSC no arranque, e o warp a acompanhar o tempo no firmware no Legion Pro 5. ↩︎ ↩︎ ↩︎

  4. tscsync — docs/HARDWARE.md — máquinas testadas, os núcleos do IdeaPad 5 aceites entre -28 e -42 ciclos, e as correções de BIOS relatadas no A485, no E495 e no T14s Gen 1. ↩︎ ↩︎ ↩︎ ↩︎

  5. Lenovo — BIOS Update Utility readme, ThinkPad E495/E595, version 1.30 — os dois modelos num só pacote, o histórico de versões até à 1.30 (14 de maio de 2024) e a sua lista de alterações. ↩︎ ↩︎

  6. Linux kernel — kernel/time/clocksource.c — o watchdog de clocksource, a sua comparação de intervalos e a mensagem «Marking clocksource %s unstable due to frequency skew». ↩︎

  7. Linux kernel — kernel-parameters — tsc=reliable desliga a verificação em funcionamento e as verificações de estabilidade no arranque; tsc=nowatchdog desliga só o watchdog de clocksource. ↩︎

  8. tscsync issue #1 — Lenovo ThinkPad E595 — os relatórios da 1.28 e da 1.30, a análise do watchdog e as alterações sugeridas. ↩︎

  9. 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», lido através de /dev/rtc. ↩︎

  10. chrony — chronyc manual — tracking: «The “frequency” is the rate by which the system’s clock would be wrong if chronyd was not correcting it.» ↩︎

  11. KVM — Management Tools — Proxmox VE, oVirt, OpenStack e as ferramentas baseadas em libvirt, todas a gerir KVM. ↩︎

  12. 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», e PVCLOCK_TSC_STABLE_BIT ligado só com o relógio mestre. ↩︎ ↩︎ ↩︎ ↩︎ ↩︎

  13. Linux kernel — arch/x86/kernel/kvmclock.c — o convidado ativa o relógio de espaço de utilizador VDSO_CLOCKMODE_PVCLOCK só quando PVCLOCK_TSC_STABLE_BIT está ligado. ↩︎

  14. Linux kernel — arch/x86/kernel/pvclock.c — sem PVCLOCK_TSC_STABLE_BIT, cada leitura é verificada contra «last_value, a global accumulator» com um compare-and-exchange atómico. ↩︎ ↩︎

  15. Proxmox VE — Host Bootloader — GRUB por omissão, systemd-boot para instalações UEFI com raiz em ZFS e o Secure Boot desligado. ↩︎