1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #include <sys/fm/protocol.h>
28 #include <signal.h>
29 #include <limits.h>
30 #include <time.h>
31
32 #include <fmd_time.h>
33 #include <fmd_alloc.h>
34 #include <fmd_error.h>
35 #include <fmd_subr.h>
36 #include <fmd.h>
37
38 void
fmd_time_gettimeofday(struct timeval * tvp)39 fmd_time_gettimeofday(struct timeval *tvp)
40 {
41 if (fmd.d_clockops->fto_gettimeofday(tvp, NULL) != 0)
42 fmd_panic("failed to read time-of-day clock");
43 }
44
45 hrtime_t
fmd_time_gethrtime(void)46 fmd_time_gethrtime(void)
47 {
48 return (fmd.d_clockops->fto_gethrtime());
49 }
50
51 void
fmd_time_addhrtime(hrtime_t delta)52 fmd_time_addhrtime(hrtime_t delta)
53 {
54 fmd.d_clockops->fto_addhrtime(delta);
55 }
56
57 void
fmd_time_waithrtime(hrtime_t delta)58 fmd_time_waithrtime(hrtime_t delta)
59 {
60 fmd.d_clockops->fto_waithrtime(delta);
61 }
62
63 void
fmd_time_waitcancel(pthread_t tid)64 fmd_time_waitcancel(pthread_t tid)
65 {
66 fmd.d_clockops->fto_waitcancel(tid);
67 }
68
69 /*
70 * To synchronize TOD with a gethrtime() source, we repeatedly sample TOD in
71 * between two calls to gethrtime(), which places a reasonably tight bound on
72 * the high-resolution time that matches the TOD value we sampled. We repeat
73 * this process several times and ultimately select the sample where the two
74 * values of gethrtime() were closest. We then assign the average of those
75 * two high-resolution times to be the gethrtime() associated with that TOD.
76 */
77 void
fmd_time_sync(fmd_timeval_t * ftv,hrtime_t * hrp,uint_t samples)78 fmd_time_sync(fmd_timeval_t *ftv, hrtime_t *hrp, uint_t samples)
79 {
80 const fmd_timeops_t *ftop = fmd.d_clockops;
81 hrtime_t hrtbase, hrtmin = INT64_MAX;
82 struct timeval todbase;
83 uint_t i;
84
85 for (i = 0; i < samples; i++) {
86 hrtime_t t0, t1, delta;
87 struct timeval tod;
88
89 t0 = ftop->fto_gethrtime();
90 (void) ftop->fto_gettimeofday(&tod, NULL);
91 t1 = ftop->fto_gethrtime();
92 delta = t1 - t0;
93
94 if (delta < hrtmin) {
95 hrtmin = delta;
96 hrtbase = t0 + delta / 2;
97 todbase = tod;
98 }
99 }
100
101 if (ftv != NULL) {
102 ftv->ftv_sec = todbase.tv_sec;
103 ftv->ftv_nsec = todbase.tv_usec * (NANOSEC / MICROSEC);
104 }
105
106 if (hrp != NULL)
107 *hrp = hrtbase;
108 }
109
110 /*
111 * Convert a high-resolution timestamp into 64-bit seconds and nanoseconds.
112 * For efficiency, the multiplication and division are expanded using the
113 * clever algorithm originally designed for the kernel in hrt2ts(). Refer to
114 * the comments in uts/common/os/timers.c for an explanation of how it works.
115 */
116 static void
fmd_time_hrt2ftv(hrtime_t hrt,fmd_timeval_t * ftv)117 fmd_time_hrt2ftv(hrtime_t hrt, fmd_timeval_t *ftv)
118 {
119 uint32_t sec, nsec, tmp;
120
121 tmp = (uint32_t)(hrt >> 30);
122 sec = tmp - (tmp >> 2);
123 sec = tmp - (sec >> 5);
124 sec = tmp + (sec >> 1);
125 sec = tmp - (sec >> 6) + 7;
126 sec = tmp - (sec >> 3);
127 sec = tmp + (sec >> 1);
128 sec = tmp + (sec >> 3);
129 sec = tmp + (sec >> 4);
130 tmp = (sec << 7) - sec - sec - sec;
131 tmp = (tmp << 7) - tmp - tmp - tmp;
132 tmp = (tmp << 7) - tmp - tmp - tmp;
133 nsec = (uint32_t)hrt - (tmp << 9);
134
135 while (nsec >= NANOSEC) {
136 nsec -= NANOSEC;
137 sec++;
138 }
139
140 ftv->ftv_sec = sec;
141 ftv->ftv_nsec = nsec;
142 }
143
144 /*
145 * Convert a high-resolution time from gethrtime() to a TOD (fmd_timeval_t).
146 * We convert 'tod_base' to nanoseconds, adjust it based on the difference
147 * between the corresponding 'hrt_base' and the event high-res time 'hrt',
148 * and then repack the result into ftv_sec and ftv_nsec for our output.
149 */
150 void
fmd_time_hrt2tod(hrtime_t hrt_base,const fmd_timeval_t * tod_base,hrtime_t hrt,fmd_timeval_t * ftv)151 fmd_time_hrt2tod(hrtime_t hrt_base, const fmd_timeval_t *tod_base,
152 hrtime_t hrt, fmd_timeval_t *ftv)
153 {
154 fmd_time_hrt2ftv(tod_base->ftv_sec * NANOSEC +
155 tod_base->ftv_nsec + (hrt - hrt_base), ftv);
156 }
157
158 /*
159 * Convert a TOD (fmd_timeval_t) to a high-resolution time from gethrtime().
160 * Note that since TOD occurred in the past, the resulting value may be a
161 * negative number according the current gethrtime() clock value.
162 */
163 void
fmd_time_tod2hrt(hrtime_t hrt_base,const fmd_timeval_t * tod_base,const fmd_timeval_t * ftv,hrtime_t * hrtp)164 fmd_time_tod2hrt(hrtime_t hrt_base, const fmd_timeval_t *tod_base,
165 const fmd_timeval_t *ftv, hrtime_t *hrtp)
166 {
167 hrtime_t tod_hrt = tod_base->ftv_sec * NANOSEC + tod_base->ftv_nsec;
168 hrtime_t ftv_hrt = ftv->ftv_sec * NANOSEC + ftv->ftv_nsec;
169
170 *hrtp = hrt_base - (tod_hrt - ftv_hrt);
171 }
172
173 /*
174 * Adjust a high-resolution time based on the low bits of time stored in ENA.
175 * The assumption here in that ENA won't wrap between the time it is computed
176 * and the time the error is queued (when we capture a full 64-bits of hrtime).
177 * We extract the relevant ENA time bits as 't0' and subtract the difference
178 * between these bits and the corresponding low bits of 'hrt' from 'hrt'.
179 *
180 * Under xVM dom0, the UE ereport is prepared after panic, therefore
181 * the full 64-bit hrtime of 't0' can be bigger than 'hrt'. In such case,
182 * we should just return 'hrt'.
183 *
184 * 't0' contains only the low bits of 64bit hrtime. It is tricky to tell
185 * whether 'hrt' or 't0' happened first. We assume there should be short
186 * period between 'hrt' and 't0', therefore to check which one came first, we
187 * test their subtraction against the highest bit of mask, if the bit is not
188 * set, then 't0' is earlier. This is equivalent to
189 * ((hrt - t0) & mask) < ((mask + 1) / 2)
190 */
191 hrtime_t
fmd_time_ena2hrt(hrtime_t hrt,uint64_t ena)192 fmd_time_ena2hrt(hrtime_t hrt, uint64_t ena)
193 {
194 hrtime_t t0, mask;
195
196 switch (ENA_FORMAT(ena)) {
197 case FM_ENA_FMT1:
198 t0 = (ena & ENA_FMT1_TIME_MASK) >> ENA_FMT1_TIME_SHFT;
199 mask = ENA_FMT1_TIME_MASK >> ENA_FMT1_TIME_SHFT;
200 if (((hrt - t0) & ((mask + 1) >> 1)) == 0)
201 hrt -= (hrt - t0) & mask;
202 break;
203 case FM_ENA_FMT2:
204 t0 = (ena & ENA_FMT2_TIME_MASK) >> ENA_FMT2_TIME_SHFT;
205 mask = ENA_FMT2_TIME_MASK >> ENA_FMT2_TIME_SHFT;
206 if (((hrt - t0) & ((mask + 1) >> 1)) == 0)
207 hrt -= (hrt - t0) & mask;
208 break;
209 }
210
211 return (hrt);
212 }
213
214 /*
215 * To implement a simulated clock, we keep track of an hrtime_t value which
216 * starts at zero and is incremented only by fmd_time_addhrtime() (i.e. when
217 * the driver of the simulation requests that the clock advance). We sample
218 * the native time-of-day clock once at the start of the simulation and then
219 * return subsequent time-of-day values by adjusting TOD using the hrtime_t
220 * clock setting. Simulated nanosleep (fmd_time_waithrtime() entry point) is
221 * implemented by waiting on fts->fts_cv for the hrtime_t to increment.
222 */
223 static void *
fmd_simulator_init(void)224 fmd_simulator_init(void)
225 {
226 fmd_timesim_t *fts = fmd_alloc(sizeof (fmd_timesim_t), FMD_SLEEP);
227 struct timeval tv;
228
229 (void) pthread_mutex_init(&fts->fts_lock, NULL);
230 (void) pthread_cond_init(&fts->fts_cv, NULL);
231 (void) gettimeofday(&tv, NULL);
232
233 fts->fts_tod = (hrtime_t)tv.tv_sec * NANOSEC +
234 (hrtime_t)tv.tv_usec * (NANOSEC / MICROSEC);
235
236 fts->fts_hrt = 0;
237 fts->fts_cancel = 0;
238
239 fmd_dprintf(FMD_DBG_TMR, "simulator tod base tv_sec=%lx hrt=%llx\n",
240 tv.tv_sec, fts->fts_tod);
241
242 return (fts);
243 }
244
245 static void
fmd_simulator_fini(void * fts)246 fmd_simulator_fini(void *fts)
247 {
248 if (fts != NULL)
249 fmd_free(fts, sizeof (fmd_timesim_t));
250 }
251
252 /*ARGSUSED*/
253 static int
fmd_simulator_tod(struct timeval * tvp,void * tzp)254 fmd_simulator_tod(struct timeval *tvp, void *tzp)
255 {
256 fmd_timesim_t *fts = fmd.d_clockptr;
257 hrtime_t tod, hrt, sec, rem;
258
259 (void) pthread_mutex_lock(&fts->fts_lock);
260
261 tod = fts->fts_tod;
262 hrt = fts->fts_hrt;
263
264 (void) pthread_mutex_unlock(&fts->fts_lock);
265
266 sec = tod / NANOSEC + hrt / NANOSEC;
267 rem = tod % NANOSEC + hrt % NANOSEC;
268
269 tvp->tv_sec = sec + rem / NANOSEC;
270 tvp->tv_usec = (rem % NANOSEC) / (NANOSEC / MICROSEC);
271
272 return (0);
273 }
274
275 static hrtime_t
fmd_simulator_hrt(void)276 fmd_simulator_hrt(void)
277 {
278 fmd_timesim_t *fts = fmd.d_clockptr;
279 hrtime_t hrt;
280
281 (void) pthread_mutex_lock(&fts->fts_lock);
282 hrt = fts->fts_hrt;
283 (void) pthread_mutex_unlock(&fts->fts_lock);
284
285 return (hrt);
286 }
287
288 static void
fmd_simulator_add(hrtime_t delta)289 fmd_simulator_add(hrtime_t delta)
290 {
291 fmd_timesim_t *fts = fmd.d_clockptr;
292
293 (void) pthread_mutex_lock(&fts->fts_lock);
294
295 if (fts->fts_hrt + delta < fts->fts_hrt)
296 fts->fts_hrt = INT64_MAX; /* do not increment past apocalypse */
297 else
298 fts->fts_hrt += delta;
299
300 TRACE((FMD_DBG_TMR, "hrt clock set %llx", fts->fts_hrt));
301 fmd_dprintf(FMD_DBG_TMR, "hrt clock set %llx\n", fts->fts_hrt);
302
303 (void) pthread_cond_broadcast(&fts->fts_cv);
304 (void) pthread_mutex_unlock(&fts->fts_lock);
305 }
306
307 static void
fmd_simulator_wait(hrtime_t delta)308 fmd_simulator_wait(hrtime_t delta)
309 {
310 fmd_timesim_t *fts = fmd.d_clockptr;
311 uint64_t hrt;
312
313 (void) pthread_mutex_lock(&fts->fts_lock);
314
315 /*
316 * If the delta causes time to wrap because we've reached the simulated
317 * apocalypse, then wait forever. We make 'hrt' unsigned so that the
318 * while-loop comparison fts_hrt < UINT64_MAX will always return true.
319 */
320 if (fts->fts_hrt + delta < fts->fts_hrt)
321 hrt = UINT64_MAX;
322 else
323 hrt = fts->fts_hrt + delta;
324
325 while (fts->fts_hrt < hrt && fts->fts_cancel == 0)
326 (void) pthread_cond_wait(&fts->fts_cv, &fts->fts_lock);
327
328 if (fts->fts_cancel != 0)
329 fts->fts_cancel--; /* cancel has been processed */
330
331 (void) pthread_mutex_unlock(&fts->fts_lock);
332 }
333
334 /*ARGSUSED*/
335 static void
fmd_simulator_cancel(pthread_t tid)336 fmd_simulator_cancel(pthread_t tid)
337 {
338 fmd_timesim_t *fts = fmd.d_clockptr;
339
340 (void) pthread_mutex_lock(&fts->fts_lock);
341 fts->fts_cancel++;
342 (void) pthread_cond_signal(&fts->fts_cv);
343 (void) pthread_mutex_unlock(&fts->fts_lock);
344 }
345
346 /*
347 * Native time is implemented by calls to gethrtime() and gettimeofday(), which
348 * are stored directly in the native time ops-vector defined below. To wait on
349 * the native clock we use nanosleep(), which we can abort using a signal. The
350 * implementation assumes that callers will have a SIGALRM handler installed.
351 */
352 static void
fmd_native_wait(hrtime_t delta)353 fmd_native_wait(hrtime_t delta)
354 {
355 timespec_t tv;
356
357 tv.tv_sec = delta / NANOSEC;
358 tv.tv_nsec = delta % NANOSEC;
359
360 (void) nanosleep(&tv, NULL);
361 }
362
363 static void
fmd_native_cancel(pthread_t tid)364 fmd_native_cancel(pthread_t tid)
365 {
366 (void) pthread_kill(tid, SIGALRM);
367 }
368
369 static void *
fmd_time_nop(void)370 fmd_time_nop(void)
371 {
372 return (NULL);
373 }
374
375 const fmd_timeops_t fmd_timeops_native = {
376 (void *(*)())fmd_time_nop, /* fto_init */
377 (void (*)())fmd_time_nop, /* fto_fini */
378 gettimeofday, /* fto_gettimeofday */
379 gethrtime, /* fto_gethrtime */
380 (void (*)())fmd_time_nop, /* fto_addhrtime */
381 fmd_native_wait, /* fto_waithrtime */
382 fmd_native_cancel, /* fto_waitcancel */
383 };
384
385 const fmd_timeops_t fmd_timeops_simulated = {
386 fmd_simulator_init, /* fto_init */
387 fmd_simulator_fini, /* fto_fini */
388 fmd_simulator_tod, /* fto_gettimeofday */
389 fmd_simulator_hrt, /* fto_gethrtime */
390 fmd_simulator_add, /* fto_addhrtime */
391 fmd_simulator_wait, /* fto_waithrtime */
392 fmd_simulator_cancel, /* fto_waitcancel */
393 };
394