sys/kern/kern_ffclock.c

   1 /*-
   2  * Copyright (c) 2011 The University of Melbourne
   3  * All rights reserved.
   4  *
   5  * This software was developed by Julien Ridoux at the University of Melbourne
   6  * under sponsorship from the FreeBSD Foundation.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 #include <sys/cdefs.h>
  31 __FBSDID("$FreeBSD$");
  32
  33 #include "opt_ffclock.h"
  34
  35 #include <sys/param.h>
  36 #include <sys/bus.h>
  37 #include <sys/kernel.h>
  38 #include <sys/lock.h>
  39 #include <sys/module.h>
  40 #include <sys/mutex.h>
  41 #include <sys/priv.h>
  42 #include <sys/proc.h>
  43 #include <sys/sbuf.h>
  44 #include <sys/sysent.h>
  45 #include <sys/sysproto.h>
  46 #include <sys/sysctl.h>
  47 #include <sys/systm.h>
  48 #include <sys/timeffc.h>
  49
  50 #ifdef FFCLOCK
  51
  52 FEATURE(ffclock, "Feed-forward clock support");
  53
  54 extern struct ffclock_estimate ffclock_estimate;
  55 extern struct bintime ffclock_boottime;
  56 extern int8_t ffclock_updated;
  57 extern struct mtx ffclock_mtx;
  58
  59 /*
  60  * Feed-forward clock absolute time. This should be the preferred way to read
  61  * the feed-forward clock for "wall-clock" type time. The flags allow to compose
  62  * various flavours of absolute time (e.g. with or without leap seconds taken
  63  * into account). If valid pointers are provided, the ffcounter value and an
  64  * upper bound on clock error associated with the bintime are provided.
  65  * NOTE: use ffclock_convert_abs() to differ the conversion of a ffcounter value
  66  * read earlier.
  67  */
  68 void
  69 ffclock_abstime(ffcounter *ffcount, struct bintime *bt,
  70     struct bintime *error_bound, uint32_t flags)
  71 {
  72         struct ffclock_estimate cest;
  73         ffcounter ffc;
  74         ffcounter update_ffcount;
  75         ffcounter ffdelta_error;
  76
  77         /* Get counter and corresponding time. */
  78         if ((flags & FFCLOCK_FAST) == FFCLOCK_FAST)
  79                 ffclock_last_tick(&ffc, bt, flags);
  80         else {
  81                 ffclock_read_counter(&ffc);
  82                 ffclock_convert_abs(ffc, bt, flags);
  83         }
  84
  85         /* Current ffclock estimate, use update_ffcount as generation number. */
  86         do {
  87                 update_ffcount = ffclock_estimate.update_ffcount;
  88                 bcopy(&ffclock_estimate, &cest, sizeof(struct ffclock_estimate));
  89         } while (update_ffcount != ffclock_estimate.update_ffcount);
  90
  91         /*
  92          * Leap second adjustment. Total as seen by synchronisation algorithm
  93          * since it started. cest.leapsec_next is the ffcounter prediction of
  94          * when the next leapsecond occurs.
  95          */
  96         if ((flags & FFCLOCK_LEAPSEC) == FFCLOCK_LEAPSEC) {
  97                 bt->sec -= cest.leapsec_total;
  98                 if (ffc > cest.leapsec_next)
  99                         bt->sec -= cest.leapsec;
 100         }
 101
 102         /* Boot time adjustment, for uptime/monotonic clocks. */
 103         if ((flags & FFCLOCK_UPTIME) == FFCLOCK_UPTIME) {
 104                 bintime_sub(bt, &ffclock_boottime);
 105         }
 106
 107         /* Compute error bound if a valid pointer has been passed. */
 108         if (error_bound) {
 109                 ffdelta_error = ffc - cest.update_ffcount;
 110                 ffclock_convert_diff(ffdelta_error, error_bound);
 111                 /* 18446744073709 = int(2^64/1e12), err_bound_rate in [ps/s] */
 112                 bintime_mul(error_bound, cest.errb_rate *
 113                     (uint64_t)18446744073709LL);
 114                 /* 18446744073 = int(2^64 / 1e9), since err_abs in [ns] */
 115                 bintime_addx(error_bound, cest.errb_abs *
 116                     (uint64_t)18446744073LL);
 117         }
 118
 119         if (ffcount)
 120                 *ffcount = ffc;
 121 }
 122
 123 /*
 124  * Feed-forward difference clock. This should be the preferred way to convert a
 125  * time interval in ffcounter values into a time interval in seconds. If a valid
 126  * pointer is passed, an upper bound on the error in computing the time interval
 127  * in seconds is provided.
 128  */
 129 void
 130 ffclock_difftime(ffcounter ffdelta, struct bintime *bt,
 131     struct bintime *error_bound)
 132 {
 133         ffcounter update_ffcount;
 134         uint32_t err_rate;
 135
 136         ffclock_convert_diff(ffdelta, bt);
 137
 138         if (error_bound) {
 139                 do {
 140                         update_ffcount = ffclock_estimate.update_ffcount;
 141                         err_rate = ffclock_estimate.errb_rate;
 142                 } while (update_ffcount != ffclock_estimate.update_ffcount);
 143
 144                 ffclock_convert_diff(ffdelta, error_bound);
 145                 /* 18446744073709 = int(2^64/1e12), err_bound_rate in [ps/s] */
 146                 bintime_mul(error_bound, err_rate * (uint64_t)18446744073709LL);
 147         }
 148 }
 149
 150 /*
 151  * Create a new kern.sysclock sysctl node, which will be home to some generic
 152  * sysclock configuration variables. Feed-forward clock specific variables will
 153  * live under the ffclock subnode.
 154  */
 155
 156 SYSCTL_NODE(_kern, OID_AUTO, sysclock, CTLFLAG_RW, 0,
 157     "System clock related configuration");
 158 SYSCTL_NODE(_kern_sysclock, OID_AUTO, ffclock, CTLFLAG_RW, 0,
 159     "Feed-forward clock configuration");
 160
 161 static char *sysclocks[] = {"feedback", "feed-forward"};
 162 #define MAX_SYSCLOCK_NAME_LEN 16
 163 #define NUM_SYSCLOCKS (sizeof(sysclocks) / sizeof(*sysclocks))
 164
 165 static int ffclock_version = 2;
 166 SYSCTL_INT(_kern_sysclock_ffclock, OID_AUTO, version, CTLFLAG_RD,
 167     &ffclock_version, 0, "Feed-forward clock kernel version");
 168
 169 /* List available sysclocks. */
 170 static int
 171 sysctl_kern_sysclock_available(SYSCTL_HANDLER_ARGS)
 172 {
 173         struct sbuf *s;
 174         int clk, error;
 175
 176         s = sbuf_new_for_sysctl(NULL, NULL,
 177             MAX_SYSCLOCK_NAME_LEN * NUM_SYSCLOCKS, req);
 178         if (s == NULL)
 179                 return (ENOMEM);
 180
 181         for (clk = 0; clk < NUM_SYSCLOCKS; clk++) {
 182                 sbuf_cat(s, sysclocks[clk]);
 183                 if (clk + 1 < NUM_SYSCLOCKS)
 184                         sbuf_cat(s, " ");
 185         }
 186         error = sbuf_finish(s);
 187         sbuf_delete(s);
 188
 189         return (error);
 190 }
 191
 192 SYSCTL_PROC(_kern_sysclock, OID_AUTO, available, CTLTYPE_STRING | CTLFLAG_RD,
 193     0, 0, sysctl_kern_sysclock_available, "A",
 194     "List of available system clocks");
 195
 196 /*
 197  * Return the name of the active system clock if read, or attempt to change
 198  * the active system clock to the user specified one if written to. The active
 199  * system clock is read when calling any of the [get]{bin,nano,micro}[up]time()
 200  * functions.
 201  */
 202 static int
 203 sysctl_kern_sysclock_active(SYSCTL_HANDLER_ARGS)
 204 {
 205         char newclock[MAX_SYSCLOCK_NAME_LEN];
 206         int error;
 207         int clk;
 208
 209         /* Return the name of the current active sysclock. */
 210         strlcpy(newclock, sysclocks[sysclock_active], sizeof(newclock));
 211         error = sysctl_handle_string(oidp, newclock, sizeof(newclock), req);
 212
 213         /* Check for error or no change */
 214         if (error != 0 || req->newptr == NULL)
 215                 goto done;
 216
 217         /* Change the active sysclock to the user specified one: */
 218         error = EINVAL;
 219         for (clk = 0; clk < NUM_SYSCLOCKS; clk++) {
 220                 if (strncmp(newclock, sysclocks[clk],
 221                     MAX_SYSCLOCK_NAME_LEN - 1)) {
 222                         continue;
 223                 }
 224                 sysclock_active = clk;
 225                 error = 0;
 226                 break;
 227         }
 228 done:
 229         return (error);
 230 }
 231
 232 SYSCTL_PROC(_kern_sysclock, OID_AUTO, active, CTLTYPE_STRING | CTLFLAG_RW,
 233     0, 0, sysctl_kern_sysclock_active, "A",
 234     "Name of the active system clock which is currently serving time");
 235
 236 static int sysctl_kern_ffclock_ffcounter_bypass = 0;
 237 SYSCTL_INT(_kern_sysclock_ffclock, OID_AUTO, ffcounter_bypass, CTLFLAG_RW,
 238     &sysctl_kern_ffclock_ffcounter_bypass, 0,
 239     "Use reliable hardware timecounter as the feed-forward counter");
 240
 241 /*
 242  * High level functions to access the Feed-Forward Clock.
 243  */
 244 void
 245 ffclock_bintime(struct bintime *bt)
 246 {
 247
 248         ffclock_abstime(NULL, bt, NULL, FFCLOCK_LERP | FFCLOCK_LEAPSEC);
 249 }
 250
 251 void
 252 ffclock_nanotime(struct timespec *tsp)
 253 {
 254         struct bintime bt;
 255
 256         ffclock_abstime(NULL, &bt, NULL, FFCLOCK_LERP | FFCLOCK_LEAPSEC);
 257         bintime2timespec(&bt, tsp);
 258 }
 259
 260 void
 261 ffclock_microtime(struct timeval *tvp)
 262 {
 263         struct bintime bt;
 264
 265         ffclock_abstime(NULL, &bt, NULL, FFCLOCK_LERP | FFCLOCK_LEAPSEC);
 266         bintime2timeval(&bt, tvp);
 267 }
 268
 269 void
 270 ffclock_getbintime(struct bintime *bt)
 271 {
 272
 273         ffclock_abstime(NULL, bt, NULL,
 274             FFCLOCK_LERP | FFCLOCK_LEAPSEC | FFCLOCK_FAST);
 275 }
 276
 277 void
 278 ffclock_getnanotime(struct timespec *tsp)
 279 {
 280         struct bintime bt;
 281
 282         ffclock_abstime(NULL, &bt, NULL,
 283             FFCLOCK_LERP | FFCLOCK_LEAPSEC | FFCLOCK_FAST);
 284         bintime2timespec(&bt, tsp);
 285 }
 286
 287 void
 288 ffclock_getmicrotime(struct timeval *tvp)
 289 {
 290         struct bintime bt;
 291
 292         ffclock_abstime(NULL, &bt, NULL,
 293             FFCLOCK_LERP | FFCLOCK_LEAPSEC | FFCLOCK_FAST);
 294         bintime2timeval(&bt, tvp);
 295 }
 296
 297 void
 298 ffclock_binuptime(struct bintime *bt)
 299 {
 300
 301         ffclock_abstime(NULL, bt, NULL, FFCLOCK_LERP | FFCLOCK_UPTIME);
 302 }
 303
 304 void
 305 ffclock_nanouptime(struct timespec *tsp)
 306 {
 307         struct bintime bt;
 308
 309         ffclock_abstime(NULL, &bt, NULL, FFCLOCK_LERP | FFCLOCK_UPTIME);
 310         bintime2timespec(&bt, tsp);
 311 }
 312
 313 void
 314 ffclock_microuptime(struct timeval *tvp)
 315 {
 316         struct bintime bt;
 317
 318         ffclock_abstime(NULL, &bt, NULL, FFCLOCK_LERP | FFCLOCK_UPTIME);
 319         bintime2timeval(&bt, tvp);
 320 }
 321
 322 void
 323 ffclock_getbinuptime(struct bintime *bt)
 324 {
 325
 326         ffclock_abstime(NULL, bt, NULL,
 327             FFCLOCK_LERP | FFCLOCK_UPTIME | FFCLOCK_FAST);
 328 }
 329
 330 void
 331 ffclock_getnanouptime(struct timespec *tsp)
 332 {
 333         struct bintime bt;
 334
 335         ffclock_abstime(NULL, &bt, NULL,
 336             FFCLOCK_LERP | FFCLOCK_UPTIME | FFCLOCK_FAST);
 337         bintime2timespec(&bt, tsp);
 338 }
 339
 340 void
 341 ffclock_getmicrouptime(struct timeval *tvp)
 342 {
 343         struct bintime bt;
 344
 345         ffclock_abstime(NULL, &bt, NULL,
 346             FFCLOCK_LERP | FFCLOCK_UPTIME | FFCLOCK_FAST);
 347         bintime2timeval(&bt, tvp);
 348 }
 349
 350 void
 351 ffclock_bindifftime(ffcounter ffdelta, struct bintime *bt)
 352 {
 353
 354         ffclock_difftime(ffdelta, bt, NULL);
 355 }
 356
 357 void
 358 ffclock_nanodifftime(ffcounter ffdelta, struct timespec *tsp)
 359 {
 360         struct bintime bt;
 361
 362         ffclock_difftime(ffdelta, &bt, NULL);
 363         bintime2timespec(&bt, tsp);
 364 }
 365
 366 void
 367 ffclock_microdifftime(ffcounter ffdelta, struct timeval *tvp)
 368 {
 369         struct bintime bt;
 370
 371         ffclock_difftime(ffdelta, &bt, NULL);
 372         bintime2timeval(&bt, tvp);
 373 }
 374
 375 /*
 376  * System call allowing userland applications to retrieve the current value of
 377  * the Feed-Forward Clock counter.
 378  */
 379 #ifndef _SYS_SYSPROTO_H_
 380 struct ffclock_getcounter_args {
 381         ffcounter *ffcount;
 382 };
 383 #endif
 384 /* ARGSUSED */
 385 int
 386 sys_ffclock_getcounter(struct thread *td, struct ffclock_getcounter_args *uap)
 387 {
 388         ffcounter ffcount;
 389         int error;
 390
 391         ffcount = 0;
 392         ffclock_read_counter(&ffcount);
 393         if (ffcount == 0)
 394                 return (EAGAIN);
 395         error = copyout(&ffcount, uap->ffcount, sizeof(ffcounter));
 396
 397         return (error);
 398 }
 399
 400 /*
 401  * System call allowing the synchronisation daemon to push new feed-foward clock
 402  * estimates to the kernel. Acquire ffclock_mtx to prevent concurrent updates
 403  * and ensure data consistency.
 404  * NOTE: ffclock_updated signals the fftimehands that new estimates are
 405  * available. The updated estimates are picked up by the fftimehands on next
 406  * tick, which could take as long as 1/hz seconds (if ticks are not missed).
 407  */
 408 #ifndef _SYS_SYSPROTO_H_
 409 struct ffclock_setestimate_args {
 410         struct ffclock_estimate *cest;
 411 };
 412 #endif
 413 /* ARGSUSED */
 414 int
 415 sys_ffclock_setestimate(struct thread *td, struct ffclock_setestimate_args *uap)
 416 {
 417         struct ffclock_estimate cest;
 418         int error;
 419
 420         /* Reuse of PRIV_CLOCK_SETTIME. */
 421         if ((error = priv_check(td, PRIV_CLOCK_SETTIME)) != 0)
 422                 return (error);
 423
 424         if ((error = copyin(uap->cest, &cest, sizeof(struct ffclock_estimate)))
 425             != 0)
 426                 return (error);
 427
 428         mtx_lock(&ffclock_mtx);
 429         memcpy(&ffclock_estimate, &cest, sizeof(struct ffclock_estimate));
 430         ffclock_updated++;
 431         mtx_unlock(&ffclock_mtx);
 432         return (error);
 433 }
 434
 435 /*
 436  * System call allowing userland applications to retrieve the clock estimates
 437  * stored within the kernel. It is useful to kickstart the synchronisation
 438  * daemon with the kernel's knowledge of hardware timecounter.
 439  */
 440 #ifndef _SYS_SYSPROTO_H_
 441 struct ffclock_getestimate_args {
 442         struct ffclock_estimate *cest;
 443 };
 444 #endif
 445 /* ARGSUSED */
 446 int
 447 sys_ffclock_getestimate(struct thread *td, struct ffclock_getestimate_args *uap)
 448 {
 449         struct ffclock_estimate cest;
 450         int error;
 451
 452         mtx_lock(&ffclock_mtx);
 453         memcpy(&cest, &ffclock_estimate, sizeof(struct ffclock_estimate));
 454         mtx_unlock(&ffclock_mtx);
 455         error = copyout(&cest, uap->cest, sizeof(struct ffclock_estimate));
 456         return (error);
 457 }
 458
 459 #else /* !FFCLOCK */
 460
 461 int
 462 sys_ffclock_getcounter(struct thread *td, struct ffclock_getcounter_args *uap)
 463 {
 464
 465         return (ENOSYS);
 466 }
 467
 468 int
 469 sys_ffclock_setestimate(struct thread *td, struct ffclock_setestimate_args *uap)
 470 {
 471
 472         return (ENOSYS);
 473 }
 474
 475 int
 476 sys_ffclock_getestimate(struct thread *td, struct ffclock_getestimate_args *uap)
 477 {
 478
 479         return (ENOSYS);
 480 }
 481
 482 #endif /* FFCLOCK */