sys/kern/kern_ffclock.c

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