GNU Linux-libre 5.4.274-gnu1
[releases.git] / arch / x86 / kernel / tsc_sync.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * check TSC synchronization.
4  *
5  * Copyright (C) 2006, Red Hat, Inc., Ingo Molnar
6  *
7  * We check whether all boot CPUs have their TSC's synchronized,
8  * print a warning if not and turn off the TSC clock-source.
9  *
10  * The warp-check is point-to-point between two CPUs, the CPU
11  * initiating the bootup is the 'source CPU', the freshly booting
12  * CPU is the 'target CPU'.
13  *
14  * Only two CPUs may participate - they can enter in any order.
15  * ( The serial nature of the boot logic and the CPU hotplug lock
16  *   protects against more than 2 CPUs entering this code. )
17  */
18 #include <linux/topology.h>
19 #include <linux/spinlock.h>
20 #include <linux/kernel.h>
21 #include <linux/smp.h>
22 #include <linux/nmi.h>
23 #include <asm/tsc.h>
24
25 struct tsc_adjust {
26         s64             bootval;
27         s64             adjusted;
28         unsigned long   nextcheck;
29         bool            warned;
30 };
31
32 static DEFINE_PER_CPU(struct tsc_adjust, tsc_adjust);
33 static struct timer_list tsc_sync_check_timer;
34
35 /*
36  * TSC's on different sockets may be reset asynchronously.
37  * This may cause the TSC ADJUST value on socket 0 to be NOT 0.
38  */
39 bool __read_mostly tsc_async_resets;
40
41 void mark_tsc_async_resets(char *reason)
42 {
43         if (tsc_async_resets)
44                 return;
45         tsc_async_resets = true;
46         pr_info("tsc: Marking TSC async resets true due to %s\n", reason);
47 }
48
49 void tsc_verify_tsc_adjust(bool resume)
50 {
51         struct tsc_adjust *adj = this_cpu_ptr(&tsc_adjust);
52         s64 curval;
53
54         if (!boot_cpu_has(X86_FEATURE_TSC_ADJUST))
55                 return;
56
57         /* Skip unnecessary error messages if TSC already unstable */
58         if (check_tsc_unstable())
59                 return;
60
61         /* Rate limit the MSR check */
62         if (!resume && time_before(jiffies, adj->nextcheck))
63                 return;
64
65         adj->nextcheck = jiffies + HZ;
66
67         rdmsrl(MSR_IA32_TSC_ADJUST, curval);
68         if (adj->adjusted == curval)
69                 return;
70
71         /* Restore the original value */
72         wrmsrl(MSR_IA32_TSC_ADJUST, adj->adjusted);
73
74         if (!adj->warned || resume) {
75                 pr_warn(FW_BUG "TSC ADJUST differs: CPU%u %lld --> %lld. Restoring\n",
76                         smp_processor_id(), adj->adjusted, curval);
77                 adj->warned = true;
78         }
79 }
80
81 /*
82  * Normally the tsc_sync will be checked every time system enters idle
83  * state, but there is still caveat that a system won't enter idle,
84  * either because it's too busy or configured purposely to not enter
85  * idle.
86  *
87  * So setup a periodic timer (every 10 minutes) to make sure the check
88  * is always on.
89  */
90
91 #define SYNC_CHECK_INTERVAL             (HZ * 600)
92
93 static void tsc_sync_check_timer_fn(struct timer_list *unused)
94 {
95         int next_cpu;
96
97         tsc_verify_tsc_adjust(false);
98
99         /* Run the check for all onlined CPUs in turn */
100         next_cpu = cpumask_next(raw_smp_processor_id(), cpu_online_mask);
101         if (next_cpu >= nr_cpu_ids)
102                 next_cpu = cpumask_first(cpu_online_mask);
103
104         tsc_sync_check_timer.expires += SYNC_CHECK_INTERVAL;
105         add_timer_on(&tsc_sync_check_timer, next_cpu);
106 }
107
108 static int __init start_sync_check_timer(void)
109 {
110         if (!cpu_feature_enabled(X86_FEATURE_TSC_ADJUST) || tsc_clocksource_reliable)
111                 return 0;
112
113         timer_setup(&tsc_sync_check_timer, tsc_sync_check_timer_fn, 0);
114         tsc_sync_check_timer.expires = jiffies + SYNC_CHECK_INTERVAL;
115         add_timer(&tsc_sync_check_timer);
116
117         return 0;
118 }
119 late_initcall(start_sync_check_timer);
120
121 static void tsc_sanitize_first_cpu(struct tsc_adjust *cur, s64 bootval,
122                                    unsigned int cpu, bool bootcpu)
123 {
124         /*
125          * First online CPU in a package stores the boot value in the
126          * adjustment value. This value might change later via the sync
127          * mechanism. If that fails we still can yell about boot values not
128          * being consistent.
129          *
130          * On the boot cpu we just force set the ADJUST value to 0 if it's
131          * non zero. We don't do that on non boot cpus because physical
132          * hotplug should have set the ADJUST register to a value > 0 so
133          * the TSC is in sync with the already running cpus.
134          *
135          * Also don't force the ADJUST value to zero if that is a valid value
136          * for socket 0 as determined by the system arch.  This is required
137          * when multiple sockets are reset asynchronously with each other
138          * and socket 0 may not have an TSC ADJUST value of 0.
139          */
140         if (bootcpu && bootval != 0) {
141                 if (likely(!tsc_async_resets)) {
142                         pr_warn(FW_BUG "TSC ADJUST: CPU%u: %lld force to 0\n",
143                                 cpu, bootval);
144                         wrmsrl(MSR_IA32_TSC_ADJUST, 0);
145                         bootval = 0;
146                 } else {
147                         pr_info("TSC ADJUST: CPU%u: %lld NOT forced to 0\n",
148                                 cpu, bootval);
149                 }
150         }
151         cur->adjusted = bootval;
152 }
153
154 #ifndef CONFIG_SMP
155 bool __init tsc_store_and_check_tsc_adjust(bool bootcpu)
156 {
157         struct tsc_adjust *cur = this_cpu_ptr(&tsc_adjust);
158         s64 bootval;
159
160         if (!boot_cpu_has(X86_FEATURE_TSC_ADJUST))
161                 return false;
162
163         /* Skip unnecessary error messages if TSC already unstable */
164         if (check_tsc_unstable())
165                 return false;
166
167         rdmsrl(MSR_IA32_TSC_ADJUST, bootval);
168         cur->bootval = bootval;
169         cur->nextcheck = jiffies + HZ;
170         tsc_sanitize_first_cpu(cur, bootval, smp_processor_id(), bootcpu);
171         return false;
172 }
173
174 #else /* !CONFIG_SMP */
175
176 /*
177  * Store and check the TSC ADJUST MSR if available
178  */
179 bool tsc_store_and_check_tsc_adjust(bool bootcpu)
180 {
181         struct tsc_adjust *ref, *cur = this_cpu_ptr(&tsc_adjust);
182         unsigned int refcpu, cpu = smp_processor_id();
183         struct cpumask *mask;
184         s64 bootval;
185
186         if (!boot_cpu_has(X86_FEATURE_TSC_ADJUST))
187                 return false;
188
189         rdmsrl(MSR_IA32_TSC_ADJUST, bootval);
190         cur->bootval = bootval;
191         cur->nextcheck = jiffies + HZ;
192         cur->warned = false;
193
194         /*
195          * If a non-zero TSC value for socket 0 may be valid then the default
196          * adjusted value cannot assumed to be zero either.
197          */
198         if (tsc_async_resets)
199                 cur->adjusted = bootval;
200
201         /*
202          * Check whether this CPU is the first in a package to come up. In
203          * this case do not check the boot value against another package
204          * because the new package might have been physically hotplugged,
205          * where TSC_ADJUST is expected to be different. When called on the
206          * boot CPU topology_core_cpumask() might not be available yet.
207          */
208         mask = topology_core_cpumask(cpu);
209         refcpu = mask ? cpumask_any_but(mask, cpu) : nr_cpu_ids;
210
211         if (refcpu >= nr_cpu_ids) {
212                 tsc_sanitize_first_cpu(cur, bootval, smp_processor_id(),
213                                        bootcpu);
214                 return false;
215         }
216
217         ref = per_cpu_ptr(&tsc_adjust, refcpu);
218         /*
219          * Compare the boot value and complain if it differs in the
220          * package.
221          */
222         if (bootval != ref->bootval)
223                 printk_once(FW_BUG "TSC ADJUST differs within socket(s), fixing all errors\n");
224
225         /*
226          * The TSC_ADJUST values in a package must be the same. If the boot
227          * value on this newly upcoming CPU differs from the adjustment
228          * value of the already online CPU in this package, set it to that
229          * adjusted value.
230          */
231         if (bootval != ref->adjusted) {
232                 cur->adjusted = ref->adjusted;
233                 wrmsrl(MSR_IA32_TSC_ADJUST, ref->adjusted);
234         }
235         /*
236          * We have the TSCs forced to be in sync on this package. Skip sync
237          * test:
238          */
239         return true;
240 }
241
242 /*
243  * Entry/exit counters that make sure that both CPUs
244  * run the measurement code at once:
245  */
246 static atomic_t start_count;
247 static atomic_t stop_count;
248 static atomic_t skip_test;
249 static atomic_t test_runs;
250
251 /*
252  * We use a raw spinlock in this exceptional case, because
253  * we want to have the fastest, inlined, non-debug version
254  * of a critical section, to be able to prove TSC time-warps:
255  */
256 static arch_spinlock_t sync_lock = __ARCH_SPIN_LOCK_UNLOCKED;
257
258 static cycles_t last_tsc;
259 static cycles_t max_warp;
260 static int nr_warps;
261 static int random_warps;
262
263 /*
264  * TSC-warp measurement loop running on both CPUs.  This is not called
265  * if there is no TSC.
266  */
267 static cycles_t check_tsc_warp(unsigned int timeout)
268 {
269         cycles_t start, now, prev, end, cur_max_warp = 0;
270         int i, cur_warps = 0;
271
272         start = rdtsc_ordered();
273         /*
274          * The measurement runs for 'timeout' msecs:
275          */
276         end = start + (cycles_t) tsc_khz * timeout;
277         now = start;
278
279         for (i = 0; ; i++) {
280                 /*
281                  * We take the global lock, measure TSC, save the
282                  * previous TSC that was measured (possibly on
283                  * another CPU) and update the previous TSC timestamp.
284                  */
285                 arch_spin_lock(&sync_lock);
286                 prev = last_tsc;
287                 now = rdtsc_ordered();
288                 last_tsc = now;
289                 arch_spin_unlock(&sync_lock);
290
291                 /*
292                  * Be nice every now and then (and also check whether
293                  * measurement is done [we also insert a 10 million
294                  * loops safety exit, so we dont lock up in case the
295                  * TSC readout is totally broken]):
296                  */
297                 if (unlikely(!(i & 7))) {
298                         if (now > end || i > 10000000)
299                                 break;
300                         cpu_relax();
301                         touch_nmi_watchdog();
302                 }
303                 /*
304                  * Outside the critical section we can now see whether
305                  * we saw a time-warp of the TSC going backwards:
306                  */
307                 if (unlikely(prev > now)) {
308                         arch_spin_lock(&sync_lock);
309                         max_warp = max(max_warp, prev - now);
310                         cur_max_warp = max_warp;
311                         /*
312                          * Check whether this bounces back and forth. Only
313                          * one CPU should observe time going backwards.
314                          */
315                         if (cur_warps != nr_warps)
316                                 random_warps++;
317                         nr_warps++;
318                         cur_warps = nr_warps;
319                         arch_spin_unlock(&sync_lock);
320                 }
321         }
322         WARN(!(now-start),
323                 "Warning: zero tsc calibration delta: %Ld [max: %Ld]\n",
324                         now-start, end-start);
325         return cur_max_warp;
326 }
327
328 /*
329  * If the target CPU coming online doesn't have any of its core-siblings
330  * online, a timeout of 20msec will be used for the TSC-warp measurement
331  * loop. Otherwise a smaller timeout of 2msec will be used, as we have some
332  * information about this socket already (and this information grows as we
333  * have more and more logical-siblings in that socket).
334  *
335  * Ideally we should be able to skip the TSC sync check on the other
336  * core-siblings, if the first logical CPU in a socket passed the sync test.
337  * But as the TSC is per-logical CPU and can potentially be modified wrongly
338  * by the bios, TSC sync test for smaller duration should be able
339  * to catch such errors. Also this will catch the condition where all the
340  * cores in the socket doesn't get reset at the same time.
341  */
342 static inline unsigned int loop_timeout(int cpu)
343 {
344         return (cpumask_weight(topology_core_cpumask(cpu)) > 1) ? 2 : 20;
345 }
346
347 /*
348  * Source CPU calls into this - it waits for the freshly booted
349  * target CPU to arrive and then starts the measurement:
350  */
351 void check_tsc_sync_source(int cpu)
352 {
353         int cpus = 2;
354
355         /*
356          * No need to check if we already know that the TSC is not
357          * synchronized or if we have no TSC.
358          */
359         if (unsynchronized_tsc())
360                 return;
361
362         /*
363          * Set the maximum number of test runs to
364          *  1 if the CPU does not provide the TSC_ADJUST MSR
365          *  3 if the MSR is available, so the target can try to adjust
366          */
367         if (!boot_cpu_has(X86_FEATURE_TSC_ADJUST))
368                 atomic_set(&test_runs, 1);
369         else
370                 atomic_set(&test_runs, 3);
371 retry:
372         /*
373          * Wait for the target to start or to skip the test:
374          */
375         while (atomic_read(&start_count) != cpus - 1) {
376                 if (atomic_read(&skip_test) > 0) {
377                         atomic_set(&skip_test, 0);
378                         return;
379                 }
380                 cpu_relax();
381         }
382
383         /*
384          * Trigger the target to continue into the measurement too:
385          */
386         atomic_inc(&start_count);
387
388         check_tsc_warp(loop_timeout(cpu));
389
390         while (atomic_read(&stop_count) != cpus-1)
391                 cpu_relax();
392
393         /*
394          * If the test was successful set the number of runs to zero and
395          * stop. If not, decrement the number of runs an check if we can
396          * retry. In case of random warps no retry is attempted.
397          */
398         if (!nr_warps) {
399                 atomic_set(&test_runs, 0);
400
401                 pr_debug("TSC synchronization [CPU#%d -> CPU#%d]: passed\n",
402                         smp_processor_id(), cpu);
403
404         } else if (atomic_dec_and_test(&test_runs) || random_warps) {
405                 /* Force it to 0 if random warps brought us here */
406                 atomic_set(&test_runs, 0);
407
408                 pr_warning("TSC synchronization [CPU#%d -> CPU#%d]:\n",
409                         smp_processor_id(), cpu);
410                 pr_warning("Measured %Ld cycles TSC warp between CPUs, "
411                            "turning off TSC clock.\n", max_warp);
412                 if (random_warps)
413                         pr_warning("TSC warped randomly between CPUs\n");
414                 mark_tsc_unstable("check_tsc_sync_source failed");
415         }
416
417         /*
418          * Reset it - just in case we boot another CPU later:
419          */
420         atomic_set(&start_count, 0);
421         random_warps = 0;
422         nr_warps = 0;
423         max_warp = 0;
424         last_tsc = 0;
425
426         /*
427          * Let the target continue with the bootup:
428          */
429         atomic_inc(&stop_count);
430
431         /*
432          * Retry, if there is a chance to do so.
433          */
434         if (atomic_read(&test_runs) > 0)
435                 goto retry;
436 }
437
438 /*
439  * Freshly booted CPUs call into this:
440  */
441 void check_tsc_sync_target(void)
442 {
443         struct tsc_adjust *cur = this_cpu_ptr(&tsc_adjust);
444         unsigned int cpu = smp_processor_id();
445         cycles_t cur_max_warp, gbl_max_warp;
446         int cpus = 2;
447
448         /* Also aborts if there is no TSC. */
449         if (unsynchronized_tsc())
450                 return;
451
452         /*
453          * Store, verify and sanitize the TSC adjust register. If
454          * successful skip the test.
455          *
456          * The test is also skipped when the TSC is marked reliable. This
457          * is true for SoCs which have no fallback clocksource. On these
458          * SoCs the TSC is frequency synchronized, but still the TSC ADJUST
459          * register might have been wreckaged by the BIOS..
460          */
461         if (tsc_store_and_check_tsc_adjust(false) || tsc_clocksource_reliable) {
462                 atomic_inc(&skip_test);
463                 return;
464         }
465
466 retry:
467         /*
468          * Register this CPU's participation and wait for the
469          * source CPU to start the measurement:
470          */
471         atomic_inc(&start_count);
472         while (atomic_read(&start_count) != cpus)
473                 cpu_relax();
474
475         cur_max_warp = check_tsc_warp(loop_timeout(cpu));
476
477         /*
478          * Store the maximum observed warp value for a potential retry:
479          */
480         gbl_max_warp = max_warp;
481
482         /*
483          * Ok, we are done:
484          */
485         atomic_inc(&stop_count);
486
487         /*
488          * Wait for the source CPU to print stuff:
489          */
490         while (atomic_read(&stop_count) != cpus)
491                 cpu_relax();
492
493         /*
494          * Reset it for the next sync test:
495          */
496         atomic_set(&stop_count, 0);
497
498         /*
499          * Check the number of remaining test runs. If not zero, the test
500          * failed and a retry with adjusted TSC is possible. If zero the
501          * test was either successful or failed terminally.
502          */
503         if (!atomic_read(&test_runs))
504                 return;
505
506         /*
507          * If the warp value of this CPU is 0, then the other CPU
508          * observed time going backwards so this TSC was ahead and
509          * needs to move backwards.
510          */
511         if (!cur_max_warp)
512                 cur_max_warp = -gbl_max_warp;
513
514         /*
515          * Add the result to the previous adjustment value.
516          *
517          * The adjustement value is slightly off by the overhead of the
518          * sync mechanism (observed values are ~200 TSC cycles), but this
519          * really depends on CPU, node distance and frequency. So
520          * compensating for this is hard to get right. Experiments show
521          * that the warp is not longer detectable when the observed warp
522          * value is used. In the worst case the adjustment needs to go
523          * through a 3rd run for fine tuning.
524          */
525         cur->adjusted += cur_max_warp;
526
527         pr_warn("TSC ADJUST compensate: CPU%u observed %lld warp. Adjust: %lld\n",
528                 cpu, cur_max_warp, cur->adjusted);
529
530         wrmsrl(MSR_IA32_TSC_ADJUST, cur->adjusted);
531         goto retry;
532
533 }
534
535 #endif /* CONFIG_SMP */