xref: /openbmc/linux/arch/x86/kernel/tsc_sync.c (revision 9ac8d3fb)
1 /*
2  * check TSC synchronization.
3  *
4  * Copyright (C) 2006, Red Hat, Inc., Ingo Molnar
5  *
6  * We check whether all boot CPUs have their TSC's synchronized,
7  * print a warning if not and turn off the TSC clock-source.
8  *
9  * The warp-check is point-to-point between two CPUs, the CPU
10  * initiating the bootup is the 'source CPU', the freshly booting
11  * CPU is the 'target CPU'.
12  *
13  * Only two CPUs may participate - they can enter in any order.
14  * ( The serial nature of the boot logic and the CPU hotplug lock
15  *   protects against more than 2 CPUs entering this code. )
16  */
17 #include <linux/spinlock.h>
18 #include <linux/kernel.h>
19 #include <linux/init.h>
20 #include <linux/smp.h>
21 #include <linux/nmi.h>
22 #include <asm/tsc.h>
23 
24 /*
25  * Entry/exit counters that make sure that both CPUs
26  * run the measurement code at once:
27  */
28 static __cpuinitdata atomic_t start_count;
29 static __cpuinitdata atomic_t stop_count;
30 
31 /*
32  * We use a raw spinlock in this exceptional case, because
33  * we want to have the fastest, inlined, non-debug version
34  * of a critical section, to be able to prove TSC time-warps:
35  */
36 static __cpuinitdata raw_spinlock_t sync_lock = __RAW_SPIN_LOCK_UNLOCKED;
37 static __cpuinitdata cycles_t last_tsc;
38 static __cpuinitdata cycles_t max_warp;
39 static __cpuinitdata int nr_warps;
40 
41 /*
42  * TSC-warp measurement loop running on both CPUs:
43  */
44 static __cpuinit void check_tsc_warp(void)
45 {
46 	cycles_t start, now, prev, end;
47 	int i;
48 
49 	start = get_cycles();
50 	/*
51 	 * The measurement runs for 20 msecs:
52 	 */
53 	end = start + tsc_khz * 20ULL;
54 	now = start;
55 
56 	for (i = 0; ; i++) {
57 		/*
58 		 * We take the global lock, measure TSC, save the
59 		 * previous TSC that was measured (possibly on
60 		 * another CPU) and update the previous TSC timestamp.
61 		 */
62 		__raw_spin_lock(&sync_lock);
63 		prev = last_tsc;
64 		now = get_cycles();
65 		last_tsc = now;
66 		__raw_spin_unlock(&sync_lock);
67 
68 		/*
69 		 * Be nice every now and then (and also check whether
70 		 * measurement is done [we also insert a 10 million
71 		 * loops safety exit, so we dont lock up in case the
72 		 * TSC readout is totally broken]):
73 		 */
74 		if (unlikely(!(i & 7))) {
75 			if (now > end || i > 10000000)
76 				break;
77 			cpu_relax();
78 			touch_nmi_watchdog();
79 		}
80 		/*
81 		 * Outside the critical section we can now see whether
82 		 * we saw a time-warp of the TSC going backwards:
83 		 */
84 		if (unlikely(prev > now)) {
85 			__raw_spin_lock(&sync_lock);
86 			max_warp = max(max_warp, prev - now);
87 			nr_warps++;
88 			__raw_spin_unlock(&sync_lock);
89 		}
90 	}
91 	WARN(!(now-start),
92 		"Warning: zero tsc calibration delta: %Ld [max: %Ld]\n",
93 			now-start, end-start);
94 }
95 
96 /*
97  * Source CPU calls into this - it waits for the freshly booted
98  * target CPU to arrive and then starts the measurement:
99  */
100 void __cpuinit check_tsc_sync_source(int cpu)
101 {
102 	int cpus = 2;
103 
104 	/*
105 	 * No need to check if we already know that the TSC is not
106 	 * synchronized:
107 	 */
108 	if (unsynchronized_tsc())
109 		return;
110 
111 	printk(KERN_INFO "checking TSC synchronization [CPU#%d -> CPU#%d]:",
112 			  smp_processor_id(), cpu);
113 
114 	/*
115 	 * Reset it - in case this is a second bootup:
116 	 */
117 	atomic_set(&stop_count, 0);
118 
119 	/*
120 	 * Wait for the target to arrive:
121 	 */
122 	while (atomic_read(&start_count) != cpus-1)
123 		cpu_relax();
124 	/*
125 	 * Trigger the target to continue into the measurement too:
126 	 */
127 	atomic_inc(&start_count);
128 
129 	check_tsc_warp();
130 
131 	while (atomic_read(&stop_count) != cpus-1)
132 		cpu_relax();
133 
134 	if (nr_warps) {
135 		printk("\n");
136 		printk(KERN_WARNING "Measured %Ld cycles TSC warp between CPUs,"
137 				    " turning off TSC clock.\n", max_warp);
138 		mark_tsc_unstable("check_tsc_sync_source failed");
139 	} else {
140 		printk(" passed.\n");
141 	}
142 
143 	/*
144 	 * Reset it - just in case we boot another CPU later:
145 	 */
146 	atomic_set(&start_count, 0);
147 	nr_warps = 0;
148 	max_warp = 0;
149 	last_tsc = 0;
150 
151 	/*
152 	 * Let the target continue with the bootup:
153 	 */
154 	atomic_inc(&stop_count);
155 }
156 
157 /*
158  * Freshly booted CPUs call into this:
159  */
160 void __cpuinit check_tsc_sync_target(void)
161 {
162 	int cpus = 2;
163 
164 	if (unsynchronized_tsc())
165 		return;
166 
167 	/*
168 	 * Register this CPU's participation and wait for the
169 	 * source CPU to start the measurement:
170 	 */
171 	atomic_inc(&start_count);
172 	while (atomic_read(&start_count) != cpus)
173 		cpu_relax();
174 
175 	check_tsc_warp();
176 
177 	/*
178 	 * Ok, we are done:
179 	 */
180 	atomic_inc(&stop_count);
181 
182 	/*
183 	 * Wait for the source CPU to print stuff:
184 	 */
185 	while (atomic_read(&stop_count) != cpus)
186 		cpu_relax();
187 }
188 #undef NR_LOOPS
189 
190