FreeBSD/Linux Kernel Cross Reference
sys/kern/kern_ffclock.c

     /*-
      * Copyright (c) 2011 The University of Melbourne
      * All rights reserved.
      *
      * This software was developed by Julien Ridoux at the University of Melbourne
      * under sponsorship from the FreeBSD Foundation.
      *
      * Redistribution and use in source and binary forms, with or without
      * modification, are permitted provided that the following conditions
     * are met:
     * 1. Redistributions of source code must retain the above copyright
     *    notice, this list of conditions and the following disclaimer.
     * 2. Redistributions in binary form must reproduce the above copyright
     *    notice, this list of conditions and the following disclaimer in the
     *    documentation and/or other materials provided with the distribution.
     *
     * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
     * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
     * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     * SUCH DAMAGE.
     */
    
    #include <sys/cdefs.h>
    __FBSDID("$FreeBSD$");
    
    #include "opt_ffclock.h"
    
    #include <sys/param.h>
    #include <sys/bus.h>
    #include <sys/kernel.h>
    #include <sys/lock.h>
    #include <sys/module.h>
    #include <sys/mutex.h>
    #include <sys/priv.h>
    #include <sys/proc.h>
    #include <sys/sbuf.h>
    #include <sys/sysent.h>
    #include <sys/sysproto.h>
    #include <sys/sysctl.h>
    #include <sys/systm.h>
    #include <sys/timeffc.h>
    
    #ifdef FFCLOCK
    
    FEATURE(ffclock, "Feed-forward clock support");
    
    extern struct ffclock_estimate ffclock_estimate;
    extern struct bintime ffclock_boottime;
    extern int8_t ffclock_updated;
    extern struct mtx ffclock_mtx;
    
    /*
     * Feed-forward clock absolute time. This should be the preferred way to read
     * the feed-forward clock for "wall-clock" type time. The flags allow to compose
     * various flavours of absolute time (e.g. with or without leap seconds taken
     * into account). If valid pointers are provided, the ffcounter value and an
     * upper bound on clock error associated with the bintime are provided.
     * NOTE: use ffclock_convert_abs() to differ the conversion of a ffcounter value
     * read earlier.
     */
    void
    ffclock_abstime(ffcounter *ffcount, struct bintime *bt,
        struct bintime *error_bound, uint32_t flags)
    {
            struct ffclock_estimate cest;
            ffcounter ffc;
            ffcounter update_ffcount;
            ffcounter ffdelta_error;
    
            /* Get counter and corresponding time. */
            if ((flags & FFCLOCK_FAST) == FFCLOCK_FAST)
                    ffclock_last_tick(&ffc, bt, flags);
            else {
                    ffclock_read_counter(&ffc);
                    ffclock_convert_abs(ffc, bt, flags);
            }
    
            /* Current ffclock estimate, use update_ffcount as generation number. */
            do {
                    update_ffcount = ffclock_estimate.update_ffcount;
                    bcopy(&ffclock_estimate, &cest, sizeof(struct ffclock_estimate));
            } while (update_ffcount != ffclock_estimate.update_ffcount);
    
            /*
             * Leap second adjustment. Total as seen by synchronisation algorithm
             * since it started. cest.leapsec_next is the ffcounter prediction of
             * when the next leapsecond occurs.
             */
            if ((flags & FFCLOCK_LEAPSEC) == FFCLOCK_LEAPSEC) {
                    bt->sec -= cest.leapsec_total;
                    if (ffc > cest.leapsec_next)
                            bt->sec -= cest.leapsec;
           }
   
           /* Boot time adjustment, for uptime/monotonic clocks. */
           if ((flags & FFCLOCK_UPTIME) == FFCLOCK_UPTIME) {
                   bintime_sub(bt, &ffclock_boottime);
           }
   
           /* Compute error bound if a valid pointer has been passed. */
           if (error_bound) {
                   ffdelta_error = ffc - cest.update_ffcount;
                   ffclock_convert_diff(ffdelta_error, error_bound);
                   /* 18446744073709 = int(2^64/1e12), err_bound_rate in [ps/s] */
                   bintime_mul(error_bound, cest.errb_rate *
                       (uint64_t)18446744073709LL);
                   /* 18446744073 = int(2^64 / 1e9), since err_abs in [ns] */
                   bintime_addx(error_bound, cest.errb_abs *
                       (uint64_t)18446744073LL);
           }
   
           if (ffcount)
                   *ffcount = ffc;
   }
   
   /*
    * Feed-forward difference clock. This should be the preferred way to convert a
    * time interval in ffcounter values into a time interval in seconds. If a valid
    * pointer is passed, an upper bound on the error in computing the time interval
    * in seconds is provided.
    */
   void
   ffclock_difftime(ffcounter ffdelta, struct bintime *bt,
       struct bintime *error_bound)
   {
           ffcounter update_ffcount;
           uint32_t err_rate;
   
           ffclock_convert_diff(ffdelta, bt);
   
           if (error_bound) {
                   do {
                           update_ffcount = ffclock_estimate.update_ffcount;
                           err_rate = ffclock_estimate.errb_rate;
                   } while (update_ffcount != ffclock_estimate.update_ffcount);
   
                   ffclock_convert_diff(ffdelta, error_bound);
                   /* 18446744073709 = int(2^64/1e12), err_bound_rate in [ps/s] */
                   bintime_mul(error_bound, err_rate * (uint64_t)18446744073709LL);
           }
   }
   
   /*
    * Create a new kern.sysclock sysctl node, which will be home to some generic
    * sysclock configuration variables. Feed-forward clock specific variables will
    * live under the ffclock subnode.
    */
   
   SYSCTL_NODE(_kern, OID_AUTO, sysclock, CTLFLAG_RW, 0,
       "System clock related configuration");
   SYSCTL_NODE(_kern_sysclock, OID_AUTO, ffclock, CTLFLAG_RW, 0,
       "Feed-forward clock configuration");
   
   static char *sysclocks[] = {"feedback", "feed-forward"};
   #define MAX_SYSCLOCK_NAME_LEN 16
   #define NUM_SYSCLOCKS nitems(sysclocks)
   
   static int ffclock_version = 2;
   SYSCTL_INT(_kern_sysclock_ffclock, OID_AUTO, version, CTLFLAG_RD,
       &ffclock_version, 0, "Feed-forward clock kernel version");
   
   /* List available sysclocks. */
   static int
   sysctl_kern_sysclock_available(SYSCTL_HANDLER_ARGS)
   {
           struct sbuf *s;
           int clk, error;
   
           s = sbuf_new_for_sysctl(NULL, NULL,
               MAX_SYSCLOCK_NAME_LEN * NUM_SYSCLOCKS, req);
           if (s == NULL)
                   return (ENOMEM);
   
           for (clk = 0; clk < NUM_SYSCLOCKS; clk++) {
                   sbuf_cat(s, sysclocks[clk]);
                   if (clk + 1 < NUM_SYSCLOCKS)
                           sbuf_cat(s, " ");
           }
           error = sbuf_finish(s);
           sbuf_delete(s);
   
           return (error);
   }
   
   SYSCTL_PROC(_kern_sysclock, OID_AUTO, available, CTLTYPE_STRING | CTLFLAG_RD,
       0, 0, sysctl_kern_sysclock_available, "A",
       "List of available system clocks");
   
   /*
    * Return the name of the active system clock if read, or attempt to change
    * the active system clock to the user specified one if written to. The active
    * system clock is read when calling any of the [get]{bin,nano,micro}[up]time()
    * functions.
    */
   static int
   sysctl_kern_sysclock_active(SYSCTL_HANDLER_ARGS)
   {
           char newclock[MAX_SYSCLOCK_NAME_LEN];
           int error;
           int clk;
   
           /* Return the name of the current active sysclock. */
           strlcpy(newclock, sysclocks[sysclock_active], sizeof(newclock));
           error = sysctl_handle_string(oidp, newclock, sizeof(newclock), req);
   
           /* Check for error or no change */
           if (error != 0 || req->newptr == NULL)
                   goto done;
   
           /* Change the active sysclock to the user specified one: */
           error = EINVAL;
           for (clk = 0; clk < NUM_SYSCLOCKS; clk++) {
                   if (strncmp(newclock, sysclocks[clk],
                       MAX_SYSCLOCK_NAME_LEN - 1)) {
                           continue;
                   }
                   sysclock_active = clk;
                   error = 0;
                   break;
           }
   done:
           return (error);
   }
   
   SYSCTL_PROC(_kern_sysclock, OID_AUTO, active, CTLTYPE_STRING | CTLFLAG_RW,
       0, 0, sysctl_kern_sysclock_active, "A",
       "Name of the active system clock which is currently serving time");
   
   static int sysctl_kern_ffclock_ffcounter_bypass = 0;
   SYSCTL_INT(_kern_sysclock_ffclock, OID_AUTO, ffcounter_bypass, CTLFLAG_RW,
       &sysctl_kern_ffclock_ffcounter_bypass, 0,
       "Use reliable hardware timecounter as the feed-forward counter");
   
   /*
    * High level functions to access the Feed-Forward Clock.
    */
   void
   ffclock_bintime(struct bintime *bt)
   {
   
           ffclock_abstime(NULL, bt, NULL, FFCLOCK_LERP | FFCLOCK_LEAPSEC);
   }
   
   void
   ffclock_nanotime(struct timespec *tsp)
   {
           struct bintime bt;
   
           ffclock_abstime(NULL, &bt, NULL, FFCLOCK_LERP | FFCLOCK_LEAPSEC);
           bintime2timespec(&bt, tsp);
   }
   
   void
   ffclock_microtime(struct timeval *tvp)
   {
           struct bintime bt;
   
           ffclock_abstime(NULL, &bt, NULL, FFCLOCK_LERP | FFCLOCK_LEAPSEC);
           bintime2timeval(&bt, tvp);
   }
   
   void
   ffclock_getbintime(struct bintime *bt)
   {
   
           ffclock_abstime(NULL, bt, NULL,
               FFCLOCK_LERP | FFCLOCK_LEAPSEC | FFCLOCK_FAST);
   }
   
   void
   ffclock_getnanotime(struct timespec *tsp)
   {
           struct bintime bt;
   
           ffclock_abstime(NULL, &bt, NULL,
               FFCLOCK_LERP | FFCLOCK_LEAPSEC | FFCLOCK_FAST);
           bintime2timespec(&bt, tsp);
   }
   
   void
   ffclock_getmicrotime(struct timeval *tvp)
   {
           struct bintime bt;
   
           ffclock_abstime(NULL, &bt, NULL,
               FFCLOCK_LERP | FFCLOCK_LEAPSEC | FFCLOCK_FAST);
           bintime2timeval(&bt, tvp);
   }
   
   void
   ffclock_binuptime(struct bintime *bt)
   {
   
           ffclock_abstime(NULL, bt, NULL, FFCLOCK_LERP | FFCLOCK_UPTIME);
   }
   
   void
   ffclock_nanouptime(struct timespec *tsp)
   {
           struct bintime bt;
   
           ffclock_abstime(NULL, &bt, NULL, FFCLOCK_LERP | FFCLOCK_UPTIME);
           bintime2timespec(&bt, tsp);
   }
   
   void
   ffclock_microuptime(struct timeval *tvp)
   {
           struct bintime bt;
   
           ffclock_abstime(NULL, &bt, NULL, FFCLOCK_LERP | FFCLOCK_UPTIME);
           bintime2timeval(&bt, tvp);
   }
   
   void
   ffclock_getbinuptime(struct bintime *bt)
   {
   
           ffclock_abstime(NULL, bt, NULL,
               FFCLOCK_LERP | FFCLOCK_UPTIME | FFCLOCK_FAST);
   }
   
   void
   ffclock_getnanouptime(struct timespec *tsp)
   {
           struct bintime bt;
   
           ffclock_abstime(NULL, &bt, NULL,
               FFCLOCK_LERP | FFCLOCK_UPTIME | FFCLOCK_FAST);
           bintime2timespec(&bt, tsp);
   }
   
   void
   ffclock_getmicrouptime(struct timeval *tvp)
   {
           struct bintime bt;
   
           ffclock_abstime(NULL, &bt, NULL,
               FFCLOCK_LERP | FFCLOCK_UPTIME | FFCLOCK_FAST);
           bintime2timeval(&bt, tvp);
   }
   
   void
   ffclock_bindifftime(ffcounter ffdelta, struct bintime *bt)
   {
   
           ffclock_difftime(ffdelta, bt, NULL);
   }
   
   void
   ffclock_nanodifftime(ffcounter ffdelta, struct timespec *tsp)
   {
           struct bintime bt;
   
           ffclock_difftime(ffdelta, &bt, NULL);
           bintime2timespec(&bt, tsp);
   }
   
   void
   ffclock_microdifftime(ffcounter ffdelta, struct timeval *tvp)
   {
           struct bintime bt;
   
           ffclock_difftime(ffdelta, &bt, NULL);
           bintime2timeval(&bt, tvp);
   }
   
   /*
    * System call allowing userland applications to retrieve the current value of
    * the Feed-Forward Clock counter.
    */
   #ifndef _SYS_SYSPROTO_H_
   struct ffclock_getcounter_args {
           ffcounter *ffcount;
   };
   #endif
   /* ARGSUSED */
   int
   sys_ffclock_getcounter(struct thread *td, struct ffclock_getcounter_args *uap)
   {
           ffcounter ffcount;
           int error;
   
           ffcount = 0;
           ffclock_read_counter(&ffcount);
           if (ffcount == 0)
                   return (EAGAIN);
           error = copyout(&ffcount, uap->ffcount, sizeof(ffcounter));
   
           return (error);
   }
   
   /*
    * System call allowing the synchronisation daemon to push new feed-foward clock
    * estimates to the kernel. Acquire ffclock_mtx to prevent concurrent updates
    * and ensure data consistency.
    * NOTE: ffclock_updated signals the fftimehands that new estimates are
    * available. The updated estimates are picked up by the fftimehands on next
    * tick, which could take as long as 1/hz seconds (if ticks are not missed).
    */
   #ifndef _SYS_SYSPROTO_H_
   struct ffclock_setestimate_args {
           struct ffclock_estimate *cest;
   };
   #endif
   /* ARGSUSED */
   int
   sys_ffclock_setestimate(struct thread *td, struct ffclock_setestimate_args *uap)
   {
           struct ffclock_estimate cest;
           int error;
   
           /* Reuse of PRIV_CLOCK_SETTIME. */
           if ((error = priv_check(td, PRIV_CLOCK_SETTIME)) != 0)
                   return (error);
   
           if ((error = copyin(uap->cest, &cest, sizeof(struct ffclock_estimate)))
               != 0)
                   return (error);
   
           mtx_lock(&ffclock_mtx);
           memcpy(&ffclock_estimate, &cest, sizeof(struct ffclock_estimate));
           ffclock_updated++;
           mtx_unlock(&ffclock_mtx);
           return (error);
   }
   
   /*
    * System call allowing userland applications to retrieve the clock estimates
    * stored within the kernel. It is useful to kickstart the synchronisation
    * daemon with the kernel's knowledge of hardware timecounter.
    */
   #ifndef _SYS_SYSPROTO_H_
   struct ffclock_getestimate_args {
           struct ffclock_estimate *cest;
   };
   #endif
   /* ARGSUSED */
   int
   sys_ffclock_getestimate(struct thread *td, struct ffclock_getestimate_args *uap)
   {
           struct ffclock_estimate cest;
           int error;
   
           mtx_lock(&ffclock_mtx);
           memcpy(&cest, &ffclock_estimate, sizeof(struct ffclock_estimate));
           mtx_unlock(&ffclock_mtx);
           error = copyout(&cest, uap->cest, sizeof(struct ffclock_estimate));
           return (error);
   }
   
   #else /* !FFCLOCK */
   
   int
   sys_ffclock_getcounter(struct thread *td, struct ffclock_getcounter_args *uap)
   {
   
           return (ENOSYS);
   }
   
   int
   sys_ffclock_setestimate(struct thread *td, struct ffclock_setestimate_args *uap)
   {
   
           return (ENOSYS);
   }
   
   int
   sys_ffclock_getestimate(struct thread *td, struct ffclock_getestimate_args *uap)
   {
   
           return (ENOSYS);
   }
   
   #endif /* FFCLOCK */

Cache object: 3de4790944cf774c76523f4d9e8b8ea9