Annotation of sys/kern/kern_tc.c, Revision 1.1.1.1
1.1 nbrk 1: /*-
2: * ----------------------------------------------------------------------------
3: * "THE BEER-WARE LICENSE" (Revision 42):
4: * <phk@FreeBSD.ORG> wrote this file. As long as you retain this notice you
5: * can do whatever you want with this stuff. If we meet some day, and you think
6: * this stuff is worth it, you can buy me a beer in return. Poul-Henning Kamp
7: * ----------------------------------------------------------------------------
8: *
9: * $OpenBSD: kern_tc.c,v 1.9 2007/05/09 17:42:19 deraadt Exp $
10: * $FreeBSD: src/sys/kern/kern_tc.c,v 1.148 2003/03/18 08:45:23 phk Exp $
11: */
12:
13: #include <sys/param.h>
14: #include <sys/kernel.h>
15: #include <sys/sysctl.h>
16: #include <sys/syslog.h>
17: #include <sys/systm.h>
18: #include <sys/timetc.h>
19: #include <sys/malloc.h>
20:
21: #ifdef __HAVE_TIMECOUNTER
22: /*
23: * A large step happens on boot. This constant detects such steps.
24: * It is relatively small so that ntp_update_second gets called enough
25: * in the typical 'missed a couple of seconds' case, but doesn't loop
26: * forever when the time step is large.
27: */
28: #define LARGE_STEP 200
29:
30: u_int dummy_get_timecount(struct timecounter *);
31:
32: void ntp_update_second(int64_t *, time_t *);
33: int sysctl_tc_hardware(void *, size_t *, void *, size_t);
34: int sysctl_tc_choice(void *, size_t *, void *, size_t);
35:
36: /*
37: * Implement a dummy timecounter which we can use until we get a real one
38: * in the air. This allows the console and other early stuff to use
39: * time services.
40: */
41:
42: u_int
43: dummy_get_timecount(struct timecounter *tc)
44: {
45: static u_int now;
46:
47: return (++now);
48: }
49:
50: static struct timecounter dummy_timecounter = {
51: dummy_get_timecount, 0, ~0u, 1000000, "dummy", -1000000
52: };
53:
54: struct timehands {
55: /* These fields must be initialized by the driver. */
56: struct timecounter *th_counter;
57: int64_t th_adjustment;
58: u_int64_t th_scale;
59: u_int th_offset_count;
60: struct bintime th_offset;
61: struct timeval th_microtime;
62: struct timespec th_nanotime;
63: /* Fields not to be copied in tc_windup start with th_generation. */
64: volatile u_int th_generation;
65: struct timehands *th_next;
66: };
67:
68: extern struct timehands th0;
69: static struct timehands th9 = { NULL, 0, 0, 0, {0, 0}, {0, 0}, {0, 0}, 0, &th0};
70: static struct timehands th8 = { NULL, 0, 0, 0, {0, 0}, {0, 0}, {0, 0}, 0, &th9};
71: static struct timehands th7 = { NULL, 0, 0, 0, {0, 0}, {0, 0}, {0, 0}, 0, &th8};
72: static struct timehands th6 = { NULL, 0, 0, 0, {0, 0}, {0, 0}, {0, 0}, 0, &th7};
73: static struct timehands th5 = { NULL, 0, 0, 0, {0, 0}, {0, 0}, {0, 0}, 0, &th6};
74: static struct timehands th4 = { NULL, 0, 0, 0, {0, 0}, {0, 0}, {0, 0}, 0, &th5};
75: static struct timehands th3 = { NULL, 0, 0, 0, {0, 0}, {0, 0}, {0, 0}, 0, &th4};
76: static struct timehands th2 = { NULL, 0, 0, 0, {0, 0}, {0, 0}, {0, 0}, 0, &th3};
77: static struct timehands th1 = { NULL, 0, 0, 0, {0, 0}, {0, 0}, {0, 0}, 0, &th2};
78: static struct timehands th0 = {
79: &dummy_timecounter,
80: 0,
81: (uint64_t)-1 / 1000000,
82: 0,
83: {1, 0},
84: {0, 0},
85: {0, 0},
86: 1,
87: &th1
88: };
89:
90: static struct timehands *volatile timehands = &th0;
91: struct timecounter *timecounter = &dummy_timecounter;
92: static struct timecounter *timecounters = &dummy_timecounter;
93:
94: volatile time_t time_second = 1;
95: volatile time_t time_uptime = 0;
96:
97: extern struct timeval adjtimedelta;
98: static struct bintime boottimebin;
99: static int timestepwarnings;
100:
101: void tc_windup(void);
102:
103: /*
104: * Return the difference between the timehands' counter value now and what
105: * was when we copied it to the timehands' offset_count.
106: */
107: static __inline u_int
108: tc_delta(struct timehands *th)
109: {
110: struct timecounter *tc;
111:
112: tc = th->th_counter;
113: return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
114: tc->tc_counter_mask);
115: }
116:
117: /*
118: * Functions for reading the time. We have to loop until we are sure that
119: * the timehands that we operated on was not updated under our feet. See
120: * the comment in <sys/time.h> for a description of these 12 functions.
121: */
122:
123: void
124: binuptime(struct bintime *bt)
125: {
126: struct timehands *th;
127: u_int gen;
128:
129: do {
130: th = timehands;
131: gen = th->th_generation;
132: *bt = th->th_offset;
133: bintime_addx(bt, th->th_scale * tc_delta(th));
134: } while (gen == 0 || gen != th->th_generation);
135: }
136:
137: void
138: nanouptime(struct timespec *tsp)
139: {
140: struct bintime bt;
141:
142: binuptime(&bt);
143: bintime2timespec(&bt, tsp);
144: }
145:
146: void
147: microuptime(struct timeval *tvp)
148: {
149: struct bintime bt;
150:
151: binuptime(&bt);
152: bintime2timeval(&bt, tvp);
153: }
154:
155: void
156: bintime(struct bintime *bt)
157: {
158:
159: binuptime(bt);
160: bintime_add(bt, &boottimebin);
161: }
162:
163: void
164: nanotime(struct timespec *tsp)
165: {
166: struct bintime bt;
167:
168: bintime(&bt);
169: bintime2timespec(&bt, tsp);
170: }
171:
172: void
173: microtime(struct timeval *tvp)
174: {
175: struct bintime bt;
176:
177: bintime(&bt);
178: bintime2timeval(&bt, tvp);
179: }
180:
181: void
182: getnanouptime(struct timespec *tsp)
183: {
184: struct timehands *th;
185: u_int gen;
186:
187: do {
188: th = timehands;
189: gen = th->th_generation;
190: bintime2timespec(&th->th_offset, tsp);
191: } while (gen == 0 || gen != th->th_generation);
192: }
193:
194: void
195: getmicrouptime(struct timeval *tvp)
196: {
197: struct timehands *th;
198: u_int gen;
199:
200: do {
201: th = timehands;
202: gen = th->th_generation;
203: bintime2timeval(&th->th_offset, tvp);
204: } while (gen == 0 || gen != th->th_generation);
205: }
206:
207: void
208: getnanotime(struct timespec *tsp)
209: {
210: struct timehands *th;
211: u_int gen;
212:
213: do {
214: th = timehands;
215: gen = th->th_generation;
216: *tsp = th->th_nanotime;
217: } while (gen == 0 || gen != th->th_generation);
218: }
219:
220: void
221: getmicrotime(struct timeval *tvp)
222: {
223: struct timehands *th;
224: u_int gen;
225:
226: do {
227: th = timehands;
228: gen = th->th_generation;
229: *tvp = th->th_microtime;
230: } while (gen == 0 || gen != th->th_generation);
231: }
232:
233: /*
234: * Initialize a new timecounter and possibly use it.
235: */
236: void
237: tc_init(struct timecounter *tc)
238: {
239: u_int u;
240:
241: u = tc->tc_frequency / tc->tc_counter_mask;
242: /* XXX: We need some margin here, 10% is a guess */
243: u *= 11;
244: u /= 10;
245: if (tc->tc_quality >= 0) {
246: if (u > hz) {
247: tc->tc_quality = -2000;
248: printf("Timecounter \"%s\" frequency %lu Hz",
249: tc->tc_name, (unsigned long)tc->tc_frequency);
250: printf(" -- Insufficient hz, needs at least %u\n", u);
251: }
252: }
253:
254: tc->tc_next = timecounters;
255: timecounters = tc;
256: /*
257: * Never automatically use a timecounter with negative quality.
258: * Even though we run on the dummy counter, switching here may be
259: * worse since this timecounter may not be monotonous.
260: */
261: if (tc->tc_quality < 0)
262: return;
263: if (tc->tc_quality < timecounter->tc_quality)
264: return;
265: if (tc->tc_quality == timecounter->tc_quality &&
266: tc->tc_frequency < timecounter->tc_frequency)
267: return;
268: (void)tc->tc_get_timecount(tc);
269: (void)tc->tc_get_timecount(tc);
270: timecounter = tc;
271: }
272:
273: /* Report the frequency of the current timecounter. */
274: u_int64_t
275: tc_getfrequency(void)
276: {
277:
278: return (timehands->th_counter->tc_frequency);
279: }
280:
281: /*
282: * Step our concept of UTC. This is done by modifying our estimate of
283: * when we booted.
284: * XXX: not locked.
285: */
286: void
287: tc_setclock(struct timespec *ts)
288: {
289: struct timespec ts2;
290: struct bintime bt, bt2;
291:
292: binuptime(&bt2);
293: timespec2bintime(ts, &bt);
294: bintime_sub(&bt, &bt2);
295: bintime_add(&bt2, &boottimebin);
296: boottimebin = bt;
297: bintime2timeval(&bt, &boottime);
298:
299: /* XXX fiddle all the little crinkly bits around the fiords... */
300: tc_windup();
301: if (timestepwarnings) {
302: bintime2timespec(&bt2, &ts2);
303: log(LOG_INFO, "Time stepped from %ld.%09ld to %ld.%09ld\n",
304: (long)ts2.tv_sec, ts2.tv_nsec,
305: (long)ts->tv_sec, ts->tv_nsec);
306: }
307: }
308:
309: /*
310: * Initialize the next struct timehands in the ring and make
311: * it the active timehands. Along the way we might switch to a different
312: * timecounter and/or do seconds processing in NTP. Slightly magic.
313: */
314: void
315: tc_windup(void)
316: {
317: struct bintime bt;
318: struct timehands *th, *tho;
319: u_int64_t scale;
320: u_int delta, ncount, ogen;
321: int i;
322: #ifdef leapsecs
323: time_t t;
324: #endif
325:
326: /*
327: * Make the next timehands a copy of the current one, but do not
328: * overwrite the generation or next pointer. While we update
329: * the contents, the generation must be zero.
330: */
331: tho = timehands;
332: th = tho->th_next;
333: ogen = th->th_generation;
334: th->th_generation = 0;
335: bcopy(tho, th, offsetof(struct timehands, th_generation));
336:
337: /*
338: * Capture a timecounter delta on the current timecounter and if
339: * changing timecounters, a counter value from the new timecounter.
340: * Update the offset fields accordingly.
341: */
342: delta = tc_delta(th);
343: if (th->th_counter != timecounter)
344: ncount = timecounter->tc_get_timecount(timecounter);
345: else
346: ncount = 0;
347: th->th_offset_count += delta;
348: th->th_offset_count &= th->th_counter->tc_counter_mask;
349: bintime_addx(&th->th_offset, th->th_scale * delta);
350:
351: #ifdef notyet
352: /*
353: * Hardware latching timecounters may not generate interrupts on
354: * PPS events, so instead we poll them. There is a finite risk that
355: * the hardware might capture a count which is later than the one we
356: * got above, and therefore possibly in the next NTP second which might
357: * have a different rate than the current NTP second. It doesn't
358: * matter in practice.
359: */
360: if (tho->th_counter->tc_poll_pps)
361: tho->th_counter->tc_poll_pps(tho->th_counter);
362: #endif
363:
364: /*
365: * Deal with NTP second processing. The for loop normally
366: * iterates at most once, but in extreme situations it might
367: * keep NTP sane if timeouts are not run for several seconds.
368: * At boot, the time step can be large when the TOD hardware
369: * has been read, so on really large steps, we call
370: * ntp_update_second only twice. We need to call it twice in
371: * case we missed a leap second.
372: */
373: bt = th->th_offset;
374: bintime_add(&bt, &boottimebin);
375: i = bt.sec - tho->th_microtime.tv_sec;
376: if (i > LARGE_STEP)
377: i = 2;
378: for (; i > 0; i--)
379: ntp_update_second(&th->th_adjustment, &bt.sec);
380:
381: /* Update the UTC timestamps used by the get*() functions. */
382: /* XXX shouldn't do this here. Should force non-`get' versions. */
383: bintime2timeval(&bt, &th->th_microtime);
384: bintime2timespec(&bt, &th->th_nanotime);
385:
386: /* Now is a good time to change timecounters. */
387: if (th->th_counter != timecounter) {
388: th->th_counter = timecounter;
389: th->th_offset_count = ncount;
390: }
391:
392: /*-
393: * Recalculate the scaling factor. We want the number of 1/2^64
394: * fractions of a second per period of the hardware counter, taking
395: * into account the th_adjustment factor which the NTP PLL/adjtime(2)
396: * processing provides us with.
397: *
398: * The th_adjustment is nanoseconds per second with 32 bit binary
399: * fraction and we want 64 bit binary fraction of second:
400: *
401: * x = a * 2^32 / 10^9 = a * 4.294967296
402: *
403: * The range of th_adjustment is +/- 5000PPM so inside a 64bit int
404: * we can only multiply by about 850 without overflowing, but that
405: * leaves suitably precise fractions for multiply before divide.
406: *
407: * Divide before multiply with a fraction of 2199/512 results in a
408: * systematic undercompensation of 10PPM of th_adjustment. On a
409: * 5000PPM adjustment this is a 0.05PPM error. This is acceptable.
410: *
411: * We happily sacrifice the lowest of the 64 bits of our result
412: * to the goddess of code clarity.
413: *
414: */
415: scale = (u_int64_t)1 << 63;
416: scale += (th->th_adjustment / 1024) * 2199;
417: scale /= th->th_counter->tc_frequency;
418: th->th_scale = scale * 2;
419:
420: /*
421: * Now that the struct timehands is again consistent, set the new
422: * generation number, making sure to not make it zero.
423: */
424: if (++ogen == 0)
425: ogen = 1;
426: th->th_generation = ogen;
427:
428: /* Go live with the new struct timehands. */
429: time_second = th->th_microtime.tv_sec;
430: time_uptime = th->th_offset.sec;
431: timehands = th;
432: }
433:
434: /* Report or change the active timecounter hardware. */
435: int
436: sysctl_tc_hardware(void *oldp, size_t *oldlenp, void *newp, size_t newlen)
437: {
438: char newname[32];
439: struct timecounter *newtc, *tc;
440: int error;
441:
442: tc = timecounter;
443: strlcpy(newname, tc->tc_name, sizeof(newname));
444:
445: error = sysctl_string(oldp, oldlenp, newp, newlen, newname, sizeof(newname));
446: if (error != 0 || strcmp(newname, tc->tc_name) == 0)
447: return (error);
448: for (newtc = timecounters; newtc != NULL; newtc = newtc->tc_next) {
449: if (strcmp(newname, newtc->tc_name) != 0)
450: continue;
451:
452: /* Warm up new timecounter. */
453: (void)newtc->tc_get_timecount(newtc);
454: (void)newtc->tc_get_timecount(newtc);
455:
456: timecounter = newtc;
457: return (0);
458: }
459: return (EINVAL);
460: }
461:
462: /* Report or change the active timecounter hardware. */
463: int
464: sysctl_tc_choice(void *oldp, size_t *oldlenp, void *newp, size_t newlen)
465: {
466: char buf[32], *spc, *choices;
467: struct timecounter *tc;
468: int error, maxlen;
469:
470: spc = "";
471: error = 0;
472: maxlen = 0;
473: for (tc = timecounters; tc != NULL; tc = tc->tc_next)
474: maxlen += sizeof(buf);
475: choices = malloc(maxlen, M_TEMP, M_WAITOK);
476: *choices = '\0';
477: for (tc = timecounters; tc != NULL; tc = tc->tc_next) {
478: snprintf(buf, sizeof(buf), "%s%s(%d)",
479: spc, tc->tc_name, tc->tc_quality);
480: spc = " ";
481: strlcat(choices, buf, maxlen);
482: }
483: error = sysctl_rdstring(oldp, oldlenp, newp, choices);
484: free(choices, M_TEMP);
485: return (error);
486: }
487:
488: /*
489: * Timecounters need to be updated every so often to prevent the hardware
490: * counter from overflowing. Updating also recalculates the cached values
491: * used by the get*() family of functions, so their precision depends on
492: * the update frequency.
493: */
494: static int tc_tick;
495:
496: void
497: tc_ticktock(void)
498: {
499: static int count;
500:
501: if (++count < tc_tick)
502: return;
503: count = 0;
504: tc_windup();
505: }
506:
507: void
508: inittimecounter(void)
509: {
510: u_int p;
511:
512: /*
513: * Set the initial timeout to
514: * max(1, <approx. number of hardclock ticks in a millisecond>).
515: * People should probably not use the sysctl to set the timeout
516: * to smaller than its inital value, since that value is the
517: * smallest reasonable one. If they want better timestamps they
518: * should use the non-"get"* functions.
519: */
520: if (hz > 1000)
521: tc_tick = (hz + 500) / 1000;
522: else
523: tc_tick = 1;
524: p = (tc_tick * 1000000) / hz;
525: #ifdef DEBUG
526: printf("Timecounters tick every %d.%03u msec\n", p / 1000, p % 1000);
527: #endif
528:
529: /* warm up new timecounter (again) and get rolling. */
530: (void)timecounter->tc_get_timecount(timecounter);
531: (void)timecounter->tc_get_timecount(timecounter);
532: }
533:
534: /*
535: * Return timecounter-related information.
536: */
537: int
538: sysctl_tc(int *name, u_int namelen, void *oldp, size_t *oldlenp,
539: void *newp, size_t newlen)
540: {
541: if (namelen != 1)
542: return (ENOTDIR);
543:
544: switch (name[0]) {
545: case KERN_TIMECOUNTER_TICK:
546: return (sysctl_rdint(oldp, oldlenp, newp, tc_tick));
547: case KERN_TIMECOUNTER_TIMESTEPWARNINGS:
548: return (sysctl_int(oldp, oldlenp, newp, newlen,
549: ×tepwarnings));
550: case KERN_TIMECOUNTER_HARDWARE:
551: return (sysctl_tc_hardware(oldp, oldlenp, newp, newlen));
552: case KERN_TIMECOUNTER_CHOICE:
553: return (sysctl_tc_choice(oldp, oldlenp, newp, newlen));
554: default:
555: return (EOPNOTSUPP);
556: }
557: /* NOTREACHED */
558: }
559:
560: void
561: ntp_update_second(int64_t *adjust, time_t *sec)
562: {
563: struct timeval adj;
564:
565: /* Skew time according to any adjtime(2) adjustments. */
566: timerclear(&adj);
567: if (adjtimedelta.tv_sec > 0)
568: adj.tv_usec = 5000;
569: else if (adjtimedelta.tv_sec == 0)
570: adj.tv_usec = MIN(500, adjtimedelta.tv_usec);
571: else if (adjtimedelta.tv_sec < -1)
572: adj.tv_usec = -5000;
573: else if (adjtimedelta.tv_sec == -1)
574: adj.tv_usec = MAX(-500, adjtimedelta.tv_usec - 1000000);
575: timersub(&adjtimedelta, &adj, &adjtimedelta);
576: *adjust = ((int64_t)adj.tv_usec * 1000) << 32;
577: *adjust += timecounter->tc_freq_adj;
578: }
579:
580: int
581: tc_adjfreq(int64_t *old, int64_t *new)
582: {
583: if (old != NULL) {
584: *old = timecounter->tc_freq_adj;
585: }
586: if (new != NULL) {
587: timecounter->tc_freq_adj = *new;
588: }
589: return 0;
590: }
591: #endif /* __HAVE_TIMECOUNTER */
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to kern_tc.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / kern