अपडेट, 11 अक्टूबर 2026, 16:30: तब से मैंने BIOS 1.30 फ़्लैश किया है। यह ऑफ़सेट ठीक नहीं करता। tscsync अब भी कोर को एक लाइन में लाता है, लेकिन दो sync बूट पर कर्नेल ने फिर भी TSC छोड़ दिया, warp check से नहीं बल्कि अपने clocksource watchdog से: BIOS 1.30: sync टिकता है, TSC फिर भी जाता है। tsc=nowatchdog जोड़ने पर TSC टिका रहा, और real-time clock के ख़िलाफ़ पाँच मिनट के माप में न कोई warp मिला न कोई drift: tsc=nowatchdog: पाँच मिनट, कोई warp नहीं। एक बूट कई बूट की कतार नहीं है, इसलिए मैं इसे टिका हुआ कह रहा हूँ, ठीक हुआ नहीं।

हर बूट, वही चेतावनी

मेरे ThinkPad E595 के कर्नेल लॉग में यह हर एक बूट पर बैठा था:

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

कुछ क्रैश नहीं हुआ। डेस्कटॉप पर कुछ नहीं उछला। मशीन बूट होने के पल से अपनी पूरी घड़ी चुपचाप एक धीमी टाइमर चिप पर चलाती रही, और अगर मैं किसी और चीज़ के लिए journal न पढ़ रहा होता तो यह हमेशा ऐसे ही चलता रहता।

Time Stamp Counter (TSC) हर CPU कोर के अंदर एक काउंटर है जो एक तय दर से टिक करता है। इसे पढ़ना एक अकेला instruction है। Linux इसे अपनी मुख्य घड़ी की तरह इस्तेमाल करता है, लेकिन सिर्फ़ तब जब हर कोर गिनती पर सहमत हो1। अगर एक कोर पीछे है तो कर्नेल उस पर भरोसा नहीं कर सकता और High Precision Event Timer (HPET) पर लौट आता है, जो एक अलग टाइमर डिवाइस है। tscsync के लेखक ने HPET पर एक clock read करीब 1.2 µs का मापा, TSC पर दसियों नैनोसेकंड के मुकाबले, और कर्नेल और डेस्कटॉप हर सेकंड दसियों हज़ार बार घड़ी पढ़ते हैं1। यह latency और बैटरी है, हर बूट पर चुकाई गई, बिना किसी फ़ायदे के।

तो कोर कितना पीछे था? तीन सेकंड से ज़्यादा। 2.1 GHz के लैपटॉप पर यह 6.6 अरब cycles है।

फ़र्मवेयर क्या सौंपता है

मैसेज CPU 0 और CPU 2 का नाम लेता है, लेकिन गड़बड़ी CPU 2 में नहीं है। बूट लोडर से tscsync के मापने पर, और शुरू होने के बाद कर्नेल के मापने पर, तस्वीर हर बार एक ही है:

कोरCPU 0 से ऑफ़सेटइसका मतलब
CPU 0, boot processor (BSP)0संदर्भ, और वही अलग निकला
CPU 1 से 7, बाकी कोर (APs)करीब +6.2 से +6.8 अरब cyclesआपस में 32 cycles के अंदर सहमत
2,096 MHz पर फ़ासला2.9 से 3.3 सेकंडboot processor पीछे है, हर बूट

सात कोर सहमत हैं। एक तीन सेकंड लेट है। फ़र्मवेयर boot processor को चालू करता है, उस पर अपना काम करता है, और उस एक काउंटर को बाकी के साथ लाइन में लाए बिना ही बूट लोडर को सौंप देता है।

tscsync से पहले और बाद boot processor का TSCपहले: जैसा फ़र्मवेयर सौंपता हैबाद में: tscsync sync mode मेंCPU 0 (BSP)CPU 1CPU 2CPU 3CPU 4CPU 5CPU 6CPU 7CPU 0 (BSP)CPU 1CPU 2CPU 3CPU 4CPU 5CPU 6CPU 7CPU 0 करीब 6.8 अरब cycles (3.25 s) पीछेCPU 1 से 7, 32 cycles के अंदर सहमतBSP आगे खिसका, हर कोर 45 cycles के अंदरLinux TSC clocksource रखता है
बाएँ: फ़र्मवेयर क्या सौंपता है। सात application processors 32 cycles के अंदर सहमत हैं; boot processor उनसे करीब 6.8 अरब cycles पीछे है। दाएँ: tscsync के UEFI में boot processor को आगे खिसकाने के बाद, हर कोर 45 cycles के अंदर है और कर्नेल का warp check पास होता है।

Linux इसे बस ठीक क्यों नहीं कर सकता? Intel CPU पर एक register है, IA32_TSC_ADJUST, जो कर्नेल को किसी कोर का काउंटर थोड़ा खिसकाने देता है, और जहाँ यह होता है वहाँ कर्नेल का sync कोड इसे इस्तेमाल करता है2। AMD Zen CPU में यह नहीं है। इसके बिना Linux में कुछ भी ऑफ़सेट ठीक नहीं कर सकता, और काउंटर सीधे लिखने की कर्नेल के अंदर की कोशिश (tsc=directsync) को upstream ने भरोसे लायक न मानकर ठुकरा दिया3।

तो कर्नेल वही अकेली ईमानदार चीज़ करता है जो बचती है। वह मापता है, दो कोर के बीच समय को पीछे जाते पाता है, चेतावनी छापता है और TSC इस्तेमाल करना बंद कर देता है2।

चालीस बूट, चालीस warp

एक बूट एक किस्सा है। इस मशीन का journal 30 मई 2026 तक जाता है, तो मैंने उससे पूछा।

बूटWarp, cycles2,096 MHz पर warp
30 मई से 11 अक्टूबर 202640 में से 406.16 से 9.88 अरब2.94 से 4.72 s
Median6.57 अरब3.14 s
करीब 27 s के पूरे power-off के बाद16.60 अरब3.15 s
tscsync sync mode में, BIOS 1.281कोई लॉग नहींTSC बना रहा
BIOS 1.30, tscsync बंद16.13 अरब2.92 s
BIOS 1.30, tscsync sync mode में2कोई लॉग नहींwatchdog ने TSC छोड़ा, नीचे देखिए
BIOS 1.30, sync mode और tsc=nowatchdog1कोई लॉग नहींTSC बना रहा

हर बूट। cold boot, reboot, इतने लंबे power-off के बाद भी कि आप सोचें कुछ भी पुराना बचा नहीं होगा। मात्रा ऊपर-नीचे होती है, जो एक Lenovo Legion पर tscsync के लेखक की अपनी खोज से मेल खाता है: वहाँ warp लगभग पूरी तरह इस बात के साथ बढ़ता है कि बूट लोडर शुरू होने से पहले मशीन फ़र्मवेयर में कितना समय बिताती है3। जो बूट लोगो पर ज़्यादा देर रुकता है वह और पीछे निकलता है।

ललचाने वाला इलाज कर्नेल कमांड लाइन पर tsc=reliable है, जो Linux को जाँचना बंद करने को कहता है। ऐसा मत कीजिए। कोर सच में तीन सेकंड अलग हैं, और जाँच बंद करने से यह नहीं बदलता; इससे बस कर्नेल एक ऐसी घड़ी इस्तेमाल करने लगता है जो किसी task के कोर बदलने पर पीछे कूद जाती है। tscsync का README भी यही कहता है, और उसके बाद आने वाली ऑडियो और वीडियो की अटकन का नाम लेता है1।

क्या मैं पूछ सकता हूँ कि यह अब भी क्यों भेजा जा रहा है?

मैं यह नहीं पूछ रहा कि किसने। मैं पूछ रहा हूँ कि Lenovo की प्रक्रिया में ऐसा क्या था जिसने एक ऐसा BIOS बाहर जाने दिया जो हर बूट पर एक कोर को तीन सेकंड पीछे छोड़ देता है।

जवाब tscsync के design notes में है, और वह तारीफ़ के लायक नहीं। Fisher-Price OS (Windows) बूट पर TSC खुद लिख देता है3। जिस लैपटॉप को सिर्फ़ उसी पर जाँचा गया हो वह पास हो जाता है, क्योंकि ऑपरेटिंग सिस्टम चुपचाप फ़र्मवेयर के पीछे सफ़ाई कर देता है। Linux अपनी सुरक्षा जाँच चालू रखता है और जो उसे दिया गया वही बताता है, और ठीक इसी वजह से गड़बड़ी वहाँ दिखती है और कहीं नहीं।

अजीब बात यह है कि बताया जाता है यह पहले भी ठीक हो चुका है। यूज़र बताते हैं कि Lenovo ने इसी तरह का बग ThinkPad A485, T14s Gen 1 AMD और E495 पर BIOS अपडेट से ठीक किया4। E495 इस मशीन का 14-इंच वाला भाई है, और दोनों एक ही BIOS बाँटते हैं: पैकेज के लिए Lenovo का अपना readme दोनों को लिस्ट करता है5।

मेरा E595 1.28 पर था और हर बूट पर warp करता था। Lenovo ने तब से 1.29 और 1.30 प्रकाशित किए हैं, और किसी की change list TSC के बारे में एक शब्द नहीं कहती; 1.30 “system randomly freeze since BIOS V1.27” और कुछ सुरक्षा मुद्दे ठीक करता है5। तो मैंने 1.30 डाला और फिर मापा। उस पर पहले बूट ने, tscsync बंद रखकर, 6,126,446,316 cycles का warp लॉग किया: 2.92 सेकंड, CPU#0 -> CPU#2, हमेशा जैसा। 1.30 इसे ठीक नहीं करता। दोनों मॉडल एक BIOS बाँटते हैं, तो अगर E495 वाली रिपोर्ट सही होती तो यह मशीन भी ठीक हो जाती। रिपोर्ट किसी BIOS वर्ज़न का नाम नहीं लेती और कोई लॉग लिंक नहीं करती4।

क्या Lenovo 2019 के एक लैपटॉप पर उस गड़बड़ी के लिए वापस जाएगा जिसे वह ऑपरेटिंग सिस्टम उनसे छिपाता है जिस पर वे टेस्ट करते हैं? नहीं।

tscsync, पहले माप

tscsync एक छोटा UEFI प्रोग्राम है जो Linux से ठीक पहले GRUB या systemd-boot से चलता है। यह फ़र्मवेयर की अपनी multiprocessor services के ज़रिए हर कोर से उसका TSC माँगता है, boot processor से हर कोर का ऑफ़सेट निकालता है, पीछे रहे काउंटर को तब तक आगे खिसकाता है जब तक वे सहमत न हों, फिर कर्नेल के अपने warp check जैसे एक टेस्ट से नतीजा जाँचता है1। यह कभी flash, NVRAM या फ़र्मवेयर सेटिंग्स नहीं लिखता; जो काउंटर यह बदलता है वे power-off पर रीसेट हो जाते हैं1।

बूट लोडर को सौंपने के लिए यह बहुत कुछ है, इसलिए बनाने से पहले मैंने कोड पढ़ा, commit 230eaa9 पर। फिर इंस्टॉल वैसे ही किया जैसे प्रोजेक्ट कहता है:

कदमकमांडक्या वापस आया
बिल्डmakeGRUB और systemd-boot बाइनरी
इंस्टॉल, read-onlysudo scripts/install.shmeasure mode, काउंटर में कुछ नहीं लिखा
Power off, बूट, देखिएtscsync-statusCPU 0 सभी 7 APs से 2,964 ms पीछे, APs माइक्रोसेकंड के अंदर सहमत
चालू कीजिएsudo scripts/set-mode.sh syncअगले बूट पर लागू

Measure mode वह हिस्सा है जो ऐसे किसी भी टूल में नकल करने लायक है। यह कुछ भी बदलने की इजाज़त मिलने से पहले आपके अपने हार्डवेयर पर गड़बड़ी दिखाता है, और अगर कोई बूट कभी Linux तक नहीं पहुँचता तो एक hang guard इसे बंद कर देता है1।

sync mode में पहला बूट, सीधे 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

और कर्नेल, एक सेकंड बाद:

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

कोई warp लाइन नहीं। कोई “unstable” नहीं। /sys/devices/system/clocksource/clocksource0/current_clocksource में tsc लिखा है। वह घड़ी पाने के लिए 121 ms का बूट टाइम जो हार्डवेयर के पास शुरू से होनी चाहिए थी। यह BIOS 1.28 पर था। 1.30 इतना साफ़-सुथरा नहीं रहा।

वे 21 नैनोसेकंड जिन्हें Linux ने नकार दिया

उस रिपोर्ट में एक लाइन है जो जितनी बुरी है उससे ज़्यादा बुरी दिखती है, और उसे छिपाने के बजाय समझाना ठीक है। tscsync के आखिरी verify pass ने एक कोर पर झंडा उठाया:

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 cycles करीब 21 नैनोसेकंड है। tscsync मोटे तौर पर 10 cycles के अंदर सहमति का लक्ष्य रखता है1, तो अपने ही लक्ष्य से CPU 7 चूक गया, और उसने यह कहा। फिर Linux बूट हुआ और HPET पर लौटा ही नहीं।

दोनों जाँच अलग सवाल पूछ रही हैं:

tscsync का ऑफ़सेट फ़ैसलाकर्नेल का warp test
सवालकाउंटर कितने अलग हैं?क्या कोर के बीच समय कभी पीछे जाता है?
तरीकाएक timed round trip से अनुमानकोर बारी-बारी से पढ़ते हैं, पिछली रीडिंग से तुलना2
पास का निशानकरीब 10 cyclesकोई रीडिंग पिछली से कम नहीं
इस बूट पर CPU 745 cycles, BADकोई warp नहीं, TSC बना रहा

उसी लाइन पर warps bsp/ap 0/0 tscsync का कर्नेल जैसा टेस्ट चलाना है। उसने कोई नहीं देखा। कर्नेल ने भी नहीं।

प्रोजेक्ट पहले से जानता है कि उसका फ़ैसला कर्नेल से सख़्त हो सकता है। उसकी हार्डवेयर लिस्ट के एक IdeaPad में चार कोर 28 से 42 cycles पर झंडे वाले थे जिन्हें कर्नेल ने मान लिया, और 2.1 से एक धीमा round trip BAD के बजाय UNSURE बताया जाता है4। उस स्थिति के लिए README का नियम सही है: कर्नेल की अपनी जाँच फ़ैसला करती है, और अगर clocksource tsc है तो वह पास हो गई1। इस मशीन पर 357 cycles का round trip धीमा नहीं है, इसलिए यह BAD निकला। जो टूल अपना हिसाब दिखाए और फिर आखिरी बात कर्नेल पर छोड़ दे, वही सही तरीका है।

BIOS 1.30: sync टिकता है, TSC फिर भी जाता है

1.30 पर मैंने tscsync को वापस sync mode में डाला और दो बार रीबूट किया। दोनों बार इसने अपना काम किया। इसने boot processor को करीब 6.17 अरब cycles आगे खिसकाया, हर कोर कुछ दर्जन cycles के अंदर निकला, और कर्नेल ने कोई warp लॉग नहीं किया। दोनों बार Linux फिर भी कुछ सेकंड बाद HPET पर पहुँच गया:

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

यह एक अलग जाँच है। warp test हर कोर के चालू होते समय चलता है और पूछता है कि क्या कोर के बीच समय कभी पीछे जाता है। clocksource watchdog बूट के बाद भी चलता रहता है। हर आधे सेकंड या उसके आसपास यह तुलना करता है कि TSC कितना आगे बढ़ा और HPET कितना, और अगर वे एक छोटे से अंतर से ज़्यादा असहमत हों तो TSC को unstable मार्क कर देता है6। एक बार मार्क हो गया तो अगले बूट तक मार्क रहता है।

कर्नेल की दो जाँच, और कौन सा बूट ऑप्शन किसे छोड़ता हैफ़र्मवेयरCPU 0 ~3 s पीछेtscsync, UEFI मेंCPU 0 आगे करता हैLinux शुरूकोर चालू होते हैंWarp checkएक बार, बूट परWatchdogहर 0.5 s, HPET से तुलनाडिफ़ॉल्टदोनों चालू: 1.30 पर TSC गया✓ जाँचा✓ जाँचाtsc=nowatchdogयह बूट: TSC बना रहा✓ जाँचा✗ छोड़ाtsc=reliableसलाह नहीं: असली warp छिपाता है✗ छोड़ा✗ छोड़ा
दो अलग जाँच TSC को छुड़वा सकती हैं। warp check एक बार चलता है, हर कोर के चालू होते समय; tscsync इस मशीन को उसके पार ले जाता है। watchdog हर आधे सेकंड HPET से तुलना करता रहता है। tsc=nowatchdog सिर्फ़ दूसरी को छोड़ता है, जबकि tsc=reliable दोनों को छोड़ता है और असली warp को छिपा देगा।
1.30 पर बूटWarp checkHPET intervalTSC intervalHPET के मुकाबले TSC
पहला sync बूटपास495,426,793 ns495,006,210 nsकरीब 850 ppm धीमा
दूसरा sync बूटपास495,136,113 ns496,026,671 nsकरीब 1,800 ppm तेज़

तो क्या TSC गलत दर पर चल रहा है? नहीं। मशीन चालू रहते मैंने TSC को कर्नेल की HPET-आधारित raw clock के ख़िलाफ़ 30 सेकंड तक, 5-सेकंड की खिड़कियों में, मापा। हर खिड़की 2,096.062 MHz पर निकली, कर्नेल के अपने calibration से करीब 4 parts per million। असली दर की गड़बड़ी दो बूट के बीच धीमे से तेज़ पर नहीं झूलती और फिर गायब नहीं होती। बूट की शुरुआत में कोई चीज़ आधे सेकंड की एक खिड़की को बिगाड़ देती है, और उससे ठीक पहले वाली remote CPU 5 read timed out लाइन एक कोर के थोड़ी देर जवाब न देने की ओर इशारा करती है। फ़र्मवेयर का CPU से समय चुराना इससे मेल खाएगा। मैंने यह साबित नहीं किया है।

दो बूट ही कुल सबूत हैं। मैं अभी नहीं कह सकता कि यह 1.30 है, संयोग है, या कुछ ऐसा जो tscsync का लिखना छेड़ देता है। 1.28 पर एक sync बूट ने TSC रखा और 1.30 पर दो ने खो दिया, और BIOS को दोष देने के लिए यह काफ़ी नहीं है।

इस मामले के लिए tsc=reliable से संकरा एक कर्नेल ऑप्शन है। tsc=nowatchdog TSC के लिए clocksource watchdog बंद करता है और बूट-टाइम warp check को छोड़ देता है7। अगर tscsync कभी sync करने में नाकाम रहा, तो कर्नेल फिर भी warp पकड़ लेगा और HPET पर लौट जाएगा। अगला टेस्ट यही था। आँकड़े, और tscsync की अपनी रिपोर्टिंग में कुछ सुझाए बदलाव, प्रोजेक्ट के issue tracker पर हैं8।

tsc=nowatchdog: पाँच मिनट, कोई warp नहीं

मैंने tsc=nowatchdog जोड़ा और रीबूट किया। tscsync ने boot processor को 6,207,104,421 cycles आगे खिसकाया, कर्नेल ने न कोई warp लॉग किया न कोई skew, और current_clocksource में tsc था। 1.30 पर इसे बनाए रखने वाला पहला बूट।

इससे बस यह साबित होता है कि TSC को छुड़वाने वाला watchdog था। इससे यह साबित नहीं होता कि TSC पर चलना सुरक्षित है, और watchdog बंद होने पर कर्नेल में अब कुछ भी नज़र नहीं रख रहा। तो मैंने खुद नज़र रखी।

मेरी पहले वाली दर जाँच यहाँ किसी काम की नहीं थी। वह TSC को CLOCK_MONOTONIC_RAW के ख़िलाफ़ मापती थी, जो तब तक ठीक था जब कर्नेल HPET पर चल रहा था। TSC पर वह घड़ी TSC से ही बनती है, तो टेस्ट काउंटर की तुलना खुद से करता। HPET को user space से पढ़ा भी नहीं जा सकता, क्योंकि Fedora का कर्नेल CONFIG_HPET_MMAP के बिना बना है। real-time clock (RTC) पढ़ा जा सकता है। यह अपने क्रिस्टल पर चलता है, और कर्नेल इसके सेकंड काउंटर के हर टिक पर एक प्रोग्राम को जगा देगा9।

तो मैंने एक छोटी जाँच लिखी, tsccheck। यह खुद को CPU 0 पर पिन करती है और हर 15 सेकंड चार टेस्ट चलाती है:

जाँचकैसेगड़बड़ी कैसी दिखती है
दरRTC के सेकंड टिक के बीच गिने गए TSC cyclesMHz का एक तरफ़ खिसकना
ऑफ़सेटCPU 0 से हर कोर तक 3,000 round trips, ऑफ़सेट सबसे तेज़ वाले सेबढ़ता हुआ ऑफ़सेट
Warpsहर round trip में, क्या किसी कोर ने पहले देखी वैल्यू से कम पढ़ाशून्य से ऊपर कुछ भी
Clocksourcecurrent_clocksource पढ़नाtsc के सिवा कुछ भी

round trip इसका मूल है। CPU 0 अपना काउंटर पढ़कर आगे देता है, दूसरा कोर अपना पढ़कर वापस देता है, और CPU 0 फिर पढ़ता है। अगर कोर सहमत हैं तो बीच वाली रीडिंग बाकी दोनों के बीच आनी चाहिए:

CPU 0 और दूसरे कोर के बीच एक round tripCPU 0CPU 1 से 7, एक बार में एकसमयt0t1t2मध्यबिंदुऑफ़सेटऑफ़सेट = t1 − (t0 + t2) / 23,000 trips में सबसे तेज़ सेwarp अगर t1 < t0 या t2 < t1समय पीछे गया: एक भी गड़बड़ी है
एक round trip। दूसरे कोर की रीडिंग, t1, की तुलना CPU 0 की दो रीडिंग के मध्यबिंदु से होती है, और 3,000 trips में सबसे तेज़ वाला ऑफ़सेट देता है। पहले देखी गई रीडिंग से कम कोई भी रीडिंग warp है, ऑफ़सेट चाहे जो हो।

जो लूप यह करता है:

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

पूरा प्रोग्राम x86-64 Linux के लिए सादा C है, जिसमें tscsync या इस लैपटॉप से बँधा कुछ नहीं। /dev/rtc0 के लिए इसे root चाहिए, और तीसरा argument journalctl -k -b | grep 'Refined TSC' से आपके अपने कर्नेल का आँकड़ा है:

gcc -O2 -Wall -pthread -o tsccheck tsccheck.c
sudo ./tsccheck 15 20 2096.073
tsccheck.c, पूरी जाँच 161 लाइनों में tsccheck.c · 4 kB

SHA-256 02eba1966a0097196acd5dfdcad9c4b315cafc1854c60f34c5b56080e6c38408।

पाँच मिनट में बीस सैंपल, बूट के ठीक बाद:

मापनतीजा
Clocksourceसभी 20 सैंपल में tsc, कोई कर्नेल मैसेज नहीं
Warpsकरीब 420,000 round trips में 0
CPU 0 से सबसे बुरा ऑफ़सेट85 cycles, करीब 41 ns, कोई रुझान नहीं
पूरे रन पर दर2,096.027 MHz, पहले मिनट से 2,096.022 से 2,096.031 के अंदर
हर 15-सेकंड की खिड़की में दर2,095.943 से 2,096.104 MHz
हर 15-सेकंड खिड़की में, और पूरे रन पर TSC की दर+20 ppm0 ppm-20 ppm-40 ppm-60 ppm0 s60 s120 s180 s240 s300 sकर्नेल का आँकड़ा, 2,096.073 MHz15 s: खिड़की -11.3 ppm, पूरा रन -11.3 ppm30 s: खिड़की -61.1 ppm, पूरा रन -36.2 ppm45 s: खिड़की -23.5 ppm, पूरा रन -32.0 ppm60 s: खिड़की +15.0 ppm, पूरा रन -20.2 ppm75 s: खिड़की -21.6 ppm, पूरा रन -20.5 ppm90 s: खिड़की -21.8 ppm, पूरा रन -20.7 ppm105 s: खिड़की -19.6 ppm, पूरा रन -20.6 ppm120 s: खिड़की -50.5 ppm, पूरा रन -24.3 ppm135 s: खिड़की +5.8 ppm, पूरा रन -20.9 ppm150 s: खिड़की -20.3 ppm, पूरा रन -20.9 ppm165 s: खिड़की -23.6 ppm, पूरा रन -21.1 ppm180 s: खिड़की -13.7 ppm, पूरा रन -20.5 ppm195 s: खिड़की -29.5 ppm, पूरा रन -21.2 ppm210 s: खिड़की -22.3 ppm, पूरा रन -21.3 ppm225 s: खिड़की -20.0 ppm, पूरा रन -21.2 ppm240 s: खिड़की -24.7 ppm, पूरा रन -21.4 ppm255 s: खिड़की -19.1 ppm, पूरा रन -21.3 ppm270 s: खिड़की -22.2 ppm, पूरा रन -21.3 ppm285 s: खिड़की -62.0 ppm, पूरा रन -23.5 ppm300 s: खिड़की +9.2 ppm, पूरा रन -21.9 ppmएक 15 s खिड़की, 61 ppm धीमीअब तक पूरा रन15-सेकंड खिड़कीअब तक पूरा रन
RTC के ख़िलाफ़ दर, कर्नेल के आँकड़े से parts per million में। अकेली खिड़कियाँ जोड़ों में उछलती हैं; पूरे रन का आँकड़ा पहले मिनट के अंदर 21 से 22 ppm धीमे पर सपाट हो जाता है और वहीं रहता है।

खिड़कियाँ जितनी बुरी हैं उससे बुरी दिखती हैं। एक देर से आया RTC टिक एक खिड़की को लंबा और अगली को छोटा कर देता है, इसलिए गलतियाँ जोड़ों में आती हैं जो एक-दूसरे को काट देती हैं: 30 सेकंड पर 61 parts per million (ppm) धीमा, 60 पर 15 ppm तेज़। drift खुद को नहीं काटता। पूरे रन का आँकड़ा मुश्किल से हिला।

पूरे रन का आँकड़ा पूरे पाँच मिनट कर्नेल के 2,096.073 MHz से 22 ppm नीचे बैठा रहता है। यह दो क्रिस्टल के बीच का फ़ासला है, और यह स्थिर रहा। chrony ने, इंटरनेट टाइम सर्वर के ख़िलाफ़ घड़ी को सँभालते हुए, इसे 16 से 19 ppm धीमा पाया10। वही दिशा, वही आकार।

ऑफ़सेट उन्हीं कुछ वैल्यू के बीच कूदते हैं, दोनों तरफ़ 10, 21 और 33 cycles, और कोई कोर दूर नहीं खिसकता। यह करीब 550 cycles के round trip का शोर है। tscsync का verify फिर भी इनमें से कुछ को BAD कहेगा। कर्नेल नहीं कहेगा।

क्या TSC टिका रहा? हाँ, मेरे पास के हर माप पर। एक बूट के बाद पाँच मिनट अब भी कई बूट की कतार नहीं है। अगला कदम यही जाँच लंबे uptime के बाद, और फिर कुछ और रीस्टार्ट पर।

इलाज की जगह फ़र्मवेयर में है

tscsync को होना ही नहीं चाहिए। इसका अपना README यही कहता है: फ़र्मवेयर वेंडर इस तरीके और कोड को लेने के लिए स्वागत है, “which is where this should be fixed”1। Lenovo के पास सोर्स है। tscsync के लेखक के पास सिर्फ़ वही था जो उनका लैपटॉप उन्हें बताता, और 80 बूट के लॉग1।

यही बात चुभती है। इलाज के लिए कंपनी के बाहर के एक अजनबी को मापना, डायग्नोज़ करना और रास्ता निकालना पड़ा, जबकि हार्डवेयर बेचने वाली फ़र्म ने उसे उसी एक ऑपरेटिंग सिस्टम पर जाँचा जो गड़बड़ी छिपाता है। जिस मशीन को आप इसलिए ठीक नहीं कर सकते कि उसका फ़र्मवेयर बंद है, वह असल में आपकी नहीं, शर्तों के साथ उधार पर है। signed updates वाला खुला फ़र्मवेयर इसे एक बार, ठीक से, किसी भी ऐसे व्यक्ति से ठीक करवा देता जिसे देखने की परवाह होती।

तब तक, tscsync के लेखक का अच्छा काम। पहले measure mode, एक hang guard, आँकड़े खुले में और एक ईमानदार फ़ैसला तब भी जब वह कर्नेल से असहमत हो। low-level टूल ऐसे ही बनने चाहिए।

उसी फ़र्मवेयर वाला हर KVM होस्ट

लैपटॉप पर इसकी कीमत थोड़ी latency और थोड़ी बैटरी है। हाइपरवाइज़र पर हर गेस्ट भी यह चुकाता है, और आगे की कोई भी बात Proxmox की वजह से नहीं है। यह सब Linux कर्नेल के KVM कोड में है, इसलिए KVM पर बने हर होस्ट पर यही है, ऊपर चाहे जो हो: Proxmox VE, oVirt, OpenStack, या सादा QEMU और libvirt11।

जब होस्ट अपना TSC खो देता है तो KVM क्या करता है

KVM अपने गेस्ट को एक स्थिर घड़ी तभी देता है जब होस्ट खुद TSC पर चलता हो। कर्नेल सोर्स में master clock, यानी किसी VM के हर vCPU के लिए एक साझा समय संदर्भ, तभी चालू होता है जब host_tsc_clocksource true हो12। HPET पर गिरिए और यह बंद हो जाता है, और कई चीज़ें एक साथ बदलती हैं:

होस्ट TSC परहोस्ट HPET पर, TSC unstable मार्क
KVM master clock12चालूबंद
एक vCPU दूसरे कोर पर जाता है12अपडेट करने को कुछ नहींउस VM के हर vCPU पर clock update ज़बरदस्ती, सेकंड में 10 तक
गेस्ट का TSC ऑफ़सेट12जैसा है वैसाहर बार जाने पर दोबारा लिखा, और catch-up mode में डाला
गेस्ट को PVCLOCK_TSC_STABLE_BIT12सेटसेट नहीं
गेस्ट का clock_gettime()13user space में पढ़ाएक system call, गेस्ट के बूट होते समय एक बार तय
vCPUs में गेस्ट के clock reads14स्वतंत्रहर read एक साझा global वैल्यू से जाँचा जाता है

आखिरी पंक्ति वह है जो बुरी तरह बढ़ती है। stable bit के बिना गेस्ट कर्नेल भरोसा नहीं कर सकता कि हर vCPU की घड़ी बाकी से सहमत है, इसलिए हर read की तुलना “last_value, a global accumulator” से होती है और अगर वह नया हो तो atomic compare-and-exchange से बदला जाता है14। गेस्ट का हर vCPU उसी एक वैल्यू पर लिखता है। जितने ज़्यादा vCPU घड़ी पढ़ते हैं, उतना ज़्यादा वे उस पर कतार लगाते हैं।

इसमें से कुछ भी एरर के रूप में नहीं दिखता। गेस्ट का clocksource अब भी kvm-clock पढ़ता है, और गेस्ट में कुछ भी आपको नहीं बताएगा कि वह धीमा क्यों हुआ।

होस्ट का clocksource KVM गेस्ट तक कैसे पहुँचता हैहोस्ट TSC परहोस्ट clocksource: tscपढ़ने को एक instructionKVM master clock चालूगेस्ट के लिए stable bit सेटगेस्ट user space में पढ़ता हैvDSO, करीब 28 nsहोस्ट HPET परहोस्ट clocksource: hpetटाइमर डिवाइस तक एक चक्करKVM master clock बंदstable bit नहीं, हर vCPU move पर updateगेस्ट system call करता हैएक साझा वैल्यू, करीब 190 nsProxmox VE, oVirt, OpenStack या सादे QEMU और libvirt पर वही कर्नेल कोड
होस्ट का clocksource तय करता है कि हर गेस्ट को क्या मिलता है। TSC पर गेस्ट घड़ी user space में पढ़ते हैं। HPET पर KVM अपना master clock छोड़ देता है, हर vCPU move clock updates करवाता है, और हर गेस्ट clock read एक system call बन जाता है जिसे उस एक वैल्यू से जाँचा जाता है जो हर vCPU बाँटता है।

इसकी कीमत, मापकर

मैंने इसे सिद्धांत पर छोड़ने के बजाय इसी लैपटॉप पर मापा। होस्ट का clocksource चलते-चलते बदला जा सकता है, जो KVM का master clock वैसे ही बंद कर देता है जैसे बूट-टाइम fallback करता है। एक फेंकने वाले गेस्ट ने 4 vCPUs के साथ होस्ट का अपना कर्नेल बूट किया, और एक छोटा initramfs जिसका अकेला प्रोग्राम clock_gettime() का समय मापता है। हर तरीके से दो रन, पहले होस्ट, फिर गेस्ट:

हर clock read के नैनोसेकंड, TSC पर होस्ट बनाम HPET पर होस्टहोस्टस्केल 0 से 2,400 nsहोस्ट, 1 थ्रेड, होस्ट TSC पर: 24 ns24 nsहोस्ट, 1 थ्रेड, होस्ट HPET पर: 1,542 ns1,542 ns1 थ्रेडहोस्ट, सभी 8 कोर, होस्ट TSC पर: 29 ns29 nsहोस्ट, सभी 8 कोर, होस्ट HPET पर: 1,922 ns1,922 nsसभी 8 कोरगेस्ट, 4 vCPUस्केल 0 से 300 nsगेस्ट, 4 vCPU, 1 vCPU, होस्ट TSC पर: 28 ns28 nsगेस्ट, 4 vCPU, 1 vCPU, होस्ट HPET पर: 187 ns187 ns1 vCPUगेस्ट, 4 vCPU, सभी 4 vCPU, होस्ट TSC पर: 31 ns31 nsगेस्ट, 4 vCPU, सभी 4 vCPU, होस्ट HPET पर: 244 ns244 nsसभी 4 vCPUहोस्ट clocksource tscहोस्ट clocksource hpet
हर clock_gettime() कॉल के नैनोसेकंड, हर तरीके के दो रन का औसत। होस्ट HPET पर 61 से 73 गुना धीमा होता है; गेस्ट एक vCPU के साथ करीब 7 गुना और चारों के साथ 8 गुना। पैनल अलग-अलग स्केल पर हैं, क्योंकि होस्ट की HPET वाली पट्टियाँ गेस्ट वाली को सपाट कर देतीं।

गेस्ट HPET की कीमत सीधे नहीं चुकाता, क्योंकि kvm-clock नीचे अब भी TSC पढ़ता है। वह जो खोता है वह user-space read और vCPUs के बीच की स्वतंत्रता है, और अकेले उसी से यह सात गुना धीमा है। चारों vCPU एक साथ पढ़ें तो कीमत और बढ़ती है, जो वही साझा global वैल्यू काम कर रही है। 32 या 64 vCPU वाला गेस्ट उस पर और ज़्यादा कतार लगाता है। मैंने वह नहीं मापा।

इस पर एक आँकड़ा रखिए। जो गेस्ट एक vCPU पर सेकंड में दस लाख बार घड़ी पढ़ता है, वह स्वस्थ होस्ट पर उस vCPU का 2.8% इसमें खर्च करता है, और इस वाले पर 19%। डेटाबेस, Java Virtual Machine (JVM) और हर वह चीज़ जो अपने काम पर टाइमस्टैंप लगाती है, घड़ी बहुत पढ़ती है।

यह रन इसे कम करके भी आँकता है। clocksource हाथ से बदलने पर master clock बंद होता है लेकिन TSC unstable मार्क नहीं होता, इसलिए ऊपर की टेबल वाले offset rewrites कभी चले ही नहीं। इस E595 पर बूट-टाइम fallback इसे unstable मार्क करता है, और उस हालत वाला होस्ट दोनों चुकाता है।

clockbench.c, बेंचमार्क, होस्ट पर या गेस्ट के init के रूप में चलाइए clockbench.c · 2 kB

होस्ट की जाँच, और सीमाएँ

गेस्ट की घड़ियाँ आख़िर नाज़ुक क्यों होती हैं, यह मैंने ptp_kvm वाली पोस्ट में बताया था; यह वही समस्या है जो नीचे से आ रही है। होस्ट की जाँच कीजिए, गेस्ट की नहीं:

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

tscsync GRUB या systemd-boot से चलता है1, जो ज़्यादातर KVM होस्ट को कवर करता है। Proxmox VE GRUB इस्तेमाल करता है, या ZFS root और Secure Boot बंद वाले UEFI इंस्टॉल पर systemd-boot15। फिर भी, किसी production node के पास ले जाने से पहले सीमाओं के बारे में ईमानदार रहिए।

सीमाइसके बारे में क्या करें
सिर्फ़ AMD Zen और Hygon1TSC_ADJUST वाले Intel होस्ट कर्नेल पहले से ठीक कर देता है
इसकी हार्डवेयर लिस्ट की हर मशीन लैपटॉप है4सर्वर को बिना टेस्ट हुआ मानिए और रिपोर्ट कीजिए
sync mode अपनी लिस्ट से बाहर के हार्डवेयर को मना करता है जब तक आप opt in न करें1override करने से पहले वजह पढ़िए
पहला sync बूट अटक सकता हैपहले measure mode, out-of-band console खुला, एक बार में एक node
BIOS अपडेट गड़बड़ी ठीक कर सकता हैउसके बाद वापस measure पर रखिए और जाँचिए1
साफ़ sync के बाद भी watchdog से TSC जा सकता हैहर बूट के बाद current_clocksource जाँचिए; अगर watchdog वजह है तो tsc=nowatchdog, फिर खुद मापिए

जो फ़र्मवेयर गड़बड़ी एक लैपटॉप की थोड़ी बैटरी खाती है, वह एक हाइपरवाइज़र से उसके चलाए हर गेस्ट का एक टुकड़ा लेती है, हर उस सेकंड जब वह चालू है, और गेस्ट के मालिकों के पास इसे देखने का कोई रास्ता नहीं। यही वजह है कि आप जो भी होस्ट चलाते हैं, किसी ने भी बनाया हो, हर एक पर current_clocksource जाँचिए।


  1. tscsync README — यह क्या करता है, HPET clock-read की कीमत, tsc=reliable इलाज क्यों नहीं है, सुरक्षा मॉडल, और UNSURE नियम। ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎

  2. Linux kernel — arch/x86/kernel/tsc_sync.c — TSC_ADJUST का इस्तेमाल, warp test और “Measured %Ld cycles TSC warp between CPUs, turning off TSC clock.” मैसेज। ↩︎ ↩︎ ↩︎

  3. tscsync — docs/DESIGN.md — AMD Zen में IA32_TSC_ADJUST नहीं है, tsc=directsync upstream ने ठुकराया, Windows बूट पर TSC खुद लिखता है, और Legion Pro 5 पर फ़र्मवेयर समय के साथ warp का बढ़ना। ↩︎ ↩︎ ↩︎

  4. tscsync — docs/HARDWARE.md — टेस्ट की गई मशीनें, -28 से -42 cycles पर मान लिए गए IdeaPad 5 के कोर, और A485, E495 और T14s Gen 1 पर बताए गए BIOS सुधार। ↩︎ ↩︎ ↩︎ ↩︎

  5. Lenovo — BIOS Update Utility readme, ThinkPad E495/E595, version 1.30 — एक पैकेज पर दोनों मॉडल, 1.30 (14 मई 2024) तक का वर्ज़न इतिहास, और उसकी change list। ↩︎ ↩︎

  6. Linux kernel — kernel/time/clocksource.c — clocksource watchdog, उसकी interval तुलना और “Marking clocksource %s unstable due to frequency skew” मैसेज। ↩︎

  7. Linux kernel — kernel-parameters — tsc=reliable runtime verification और बूट-टाइम stability checks बंद करता है; tsc=nowatchdog सिर्फ़ clocksource watchdog बंद करता है। ↩︎

  8. tscsync issue #1 — Lenovo ThinkPad E595 — 1.28 और 1.30 की रिपोर्ट, watchdog विश्लेषण और सुझाए गए बदलाव। ↩︎

  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”, /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 और libvirt-आधारित टूल, सब 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”, और PVCLOCK_TSC_STABLE_BIT सिर्फ़ master clock के साथ सेट होता है। ↩︎ ↩︎ ↩︎ ↩︎ ↩︎

  13. Linux kernel — arch/x86/kernel/kvmclock.c — गेस्ट VDSO_CLOCKMODE_PVCLOCK user-space clock तभी चालू करता है जब PVCLOCK_TSC_STABLE_BIT सेट हो। ↩︎

  14. Linux kernel — arch/x86/kernel/pvclock.c — PVCLOCK_TSC_STABLE_BIT के बिना हर read एक atomic compare-and-exchange के साथ “last_value, a global accumulator” से जाँचा जाता है। ↩︎ ↩︎

  15. Proxmox VE — Host Bootloader — डिफ़ॉल्ट रूप से GRUB, ZFS root और Secure Boot बंद वाले UEFI इंस्टॉल के लिए systemd-boot। ↩︎