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=nowatchdogacrescentado, 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úcleo | Desvio em relação ao CPU 0 | O que quer dizer |
|---|---|---|
| CPU 0, o processador de arranque (BSP) | 0 | a 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 ciclos | todos concordam entre si a menos de 32 ciclos |
| Diferença a 2096 MHz | 2,9 a 3,3 segundos | o 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.
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.
| Arranques | Warp, ciclos | Warp a 2096 MHz | |
|---|---|---|---|
| 30 de maio a 11 de outubro de 2026 | 40 de 40 | 6,16 a 9,88 mil milhões | 2,94 a 4,72 s |
| Mediana | 6,57 mil milhões | 3,14 s | |
| Depois de desligar por completo cerca de 27 s | 1 | 6,60 mil milhões | 3,15 s |
| Com o tscsync em modo sync, BIOS 1.28 | 1 | nenhum registado | TSC mantido |
| BIOS 1.30, tscsync desligado | 1 | 6,13 mil milhões | 2,92 s |
| BIOS 1.30, tscsync em modo sync | 2 | nenhum registado | TSC deixado cair pelo watchdog, ver abaixo |
BIOS 1.30, modo sync e tsc=nowatchdog | 1 | nenhum registado | TSC 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:
| Passo | Comando | O que veio de volta |
|---|---|---|
| Compilar | make | binários para GRUB e systemd-boot |
| Instalar, só de leitura | sudo scripts/install.sh | modo measure, nada escrito nos contadores |
| Desligar, arrancar, ver | tscsync-status | CPU 0 2964 ms atrás dos 7 APs, os APs a concordar a menos de microssegundos |
| Ligar | sudo scripts/set-mode.sh sync | faz 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 tscsync | Teste de warp do kernel | |
|---|---|---|
| Pergunta | quão afastados estão os contadores? | o tempo alguma vez anda para trás entre núcleos? |
| Método | estimativa a partir de uma ida e volta cronometrada | os núcleos leem à vez e comparam com a última leitura2 |
| Critério | cerca de 10 ciclos | nenhuma leitura mais baixa do que a anterior |
| CPU 7 neste arranque | 45 ciclos, BAD | nenhum 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.
tsc=nowatchdog salta só a segunda, enquanto tsc=reliable salta as duas e esconderia um warp real.| Arranque na 1.30 | Verificação de warp | Intervalo HPET | Intervalo TSC | TSC face ao HPET |
|---|---|---|---|---|
| Primeiro arranque com sync | passou | 495 426 793 ns | 495 006 210 ns | cerca de 850 ppm lento |
| Segundo arranque com sync | passou | 495 136 113 ns | 496 026 671 ns | cerca 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ção | Como | Como se vê uma falha |
|---|---|---|
| Ritmo | ciclos do TSC contados entre tiques de segundo do RTC | os MHz a derivar para um lado |
| Desvio | 3000 idas e voltas do CPU 0 a cada núcleo, desvio tirado da mais rápida | um desvio que cresce |
| Warps | em cada ida e volta, algum núcleo leu um valor mais baixo do que um já visto | qualquer coisa acima de zero |
| Clocksource | ler current_clocksource | qualquer 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:
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
SHA-256 02eba1966a0097196acd5dfdcad9c4b315cafc1854c60f34c5b56080e6c38408.
Vinte amostras ao longo de cinco minutos, logo a seguir ao arranque:
| Medida | Resultado |
|---|---|
| Clocksource | tsc nas 20 amostras, nenhuma mensagem do kernel |
| Warps | 0 em cerca de 420 000 idas e voltas |
| Pior desvio face ao CPU 0 | 85 ciclos, cerca de 41 ns, sem tendência |
| Ritmo na execução toda | 2096,027 MHz, entre 2096,022 e 2096,031 a partir do primeiro minuto |
| Ritmo por janela de 15 segundos | 2095,943 a 2096,104 MHz |
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 TSC | Host no HPET, TSC marcado instável | |
|---|---|---|
| Relógio mestre do KVM12 | ligado | desligado |
| Um vCPU muda para outro núcleo12 | nada a atualizar | uma atualização de relógio forçada em todos os vCPU dessa VM, até 10 por segundo |
| O desvio do TSC do convidado12 | deixado em paz | reescrito em cada mudança, e posto em modo de recuperação |
PVCLOCK_TSC_STABLE_BIT para os convidados12 | ligado | não ligado |
clock_gettime() no convidado13 | lido no espaço de utilizador | uma chamada ao sistema, decidida uma vez quando o convidado arranca |
| Leituras do relógio entre vCPU no convidado14 | independentes | cada 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.
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:
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 convidadoVerificar 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.
| Limite | O que fazer |
|---|---|
| Só AMD Zen e Hygon1 | os hosts Intel com TSC_ADJUST já são corrigidos pelo kernel |
| Todas as máquinas da sua lista de hardware são portáteis4 | trata um servidor como não testado e reporta-o |
| O modo sync recusa hardware fora da lista, a não ser que optes por ele1 | lê porquê antes de o forçares |
| Um primeiro arranque com sync pode bloquear | modo measure primeiro, consola fora de banda aberta, um nó de cada vez |
| Uma atualização de BIOS pode corrigir a falha | volta a pô-lo em measure depois e verifica1 |
| Uma sincronização limpa pode ainda perder o TSC para o watchdog | verifica 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.
tscsync README — o que faz, o custo de ler o relógio no HPET, porque é que
tsc=reliablenão é solução, o modelo de segurança e a regra doUNSURE. ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎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.». ↩︎ ↩︎ ↩︎tscsync — docs/DESIGN.md — o AMD Zen não tem
IA32_TSC_ADJUST,tsc=directsyncrejeitado 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. ↩︎ ↩︎ ↩︎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. ↩︎ ↩︎ ↩︎ ↩︎
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. ↩︎ ↩︎
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». ↩︎
Linux kernel — kernel-parameters —
tsc=reliabledesliga a verificação em funcionamento e as verificações de estabilidade no arranque;tsc=nowatchdogdesliga só o watchdog de clocksource. ↩︎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. ↩︎
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. ↩︎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 as ferramentas baseadas em libvirt, todas a gerir 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_BITligado só com o relógio mestre. ↩︎ ↩︎ ↩︎ ↩︎ ↩︎Linux kernel — arch/x86/kernel/kvmclock.c — o convidado ativa o relógio de espaço de utilizador
VDSO_CLOCKMODE_PVCLOCKsó quandoPVCLOCK_TSC_STABLE_BITestá ligado. ↩︎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. ↩︎ ↩︎Proxmox VE — Host Bootloader — GRUB por omissão, systemd-boot para instalações UEFI com raiz em ZFS e o Secure Boot desligado. ↩︎