The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

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

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    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 
   10 #include <sys/cdefs.h>
   11 __FBSDID("$FreeBSD: releng/9.0/sys/kern/kern_tc.c 224042 2011-07-14 21:00:26Z jkim $");
   12 
   13 #include "opt_ntp.h"
   14 
   15 #include <sys/param.h>
   16 #include <sys/kernel.h>
   17 #include <sys/sysctl.h>
   18 #include <sys/syslog.h>
   19 #include <sys/systm.h>
   20 #include <sys/timepps.h>
   21 #include <sys/timetc.h>
   22 #include <sys/timex.h>
   23 
   24 /*
   25  * A large step happens on boot.  This constant detects such steps.
   26  * It is relatively small so that ntp_update_second gets called enough
   27  * in the typical 'missed a couple of seconds' case, but doesn't loop
   28  * forever when the time step is large.
   29  */
   30 #define LARGE_STEP      200
   31 
   32 /*
   33  * Implement a dummy timecounter which we can use until we get a real one
   34  * in the air.  This allows the console and other early stuff to use
   35  * time services.
   36  */
   37 
   38 static u_int
   39 dummy_get_timecount(struct timecounter *tc)
   40 {
   41         static u_int now;
   42 
   43         return (++now);
   44 }
   45 
   46 static struct timecounter dummy_timecounter = {
   47         dummy_get_timecount, 0, ~0u, 1000000, "dummy", -1000000
   48 };
   49 
   50 struct timehands {
   51         /* These fields must be initialized by the driver. */
   52         struct timecounter      *th_counter;
   53         int64_t                 th_adjustment;
   54         uint64_t                th_scale;
   55         u_int                   th_offset_count;
   56         struct bintime          th_offset;
   57         struct timeval          th_microtime;
   58         struct timespec         th_nanotime;
   59         /* Fields not to be copied in tc_windup start with th_generation. */
   60         volatile u_int          th_generation;
   61         struct timehands        *th_next;
   62 };
   63 
   64 static struct timehands th0;
   65 static struct timehands th9 = { NULL, 0, 0, 0, {0, 0}, {0, 0}, {0, 0}, 0, &th0};
   66 static struct timehands th8 = { NULL, 0, 0, 0, {0, 0}, {0, 0}, {0, 0}, 0, &th9};
   67 static struct timehands th7 = { NULL, 0, 0, 0, {0, 0}, {0, 0}, {0, 0}, 0, &th8};
   68 static struct timehands th6 = { NULL, 0, 0, 0, {0, 0}, {0, 0}, {0, 0}, 0, &th7};
   69 static struct timehands th5 = { NULL, 0, 0, 0, {0, 0}, {0, 0}, {0, 0}, 0, &th6};
   70 static struct timehands th4 = { NULL, 0, 0, 0, {0, 0}, {0, 0}, {0, 0}, 0, &th5};
   71 static struct timehands th3 = { NULL, 0, 0, 0, {0, 0}, {0, 0}, {0, 0}, 0, &th4};
   72 static struct timehands th2 = { NULL, 0, 0, 0, {0, 0}, {0, 0}, {0, 0}, 0, &th3};
   73 static struct timehands th1 = { NULL, 0, 0, 0, {0, 0}, {0, 0}, {0, 0}, 0, &th2};
   74 static struct timehands th0 = {
   75         &dummy_timecounter,
   76         0,
   77         (uint64_t)-1 / 1000000,
   78         0,
   79         {1, 0},
   80         {0, 0},
   81         {0, 0},
   82         1,
   83         &th1
   84 };
   85 
   86 static struct timehands *volatile timehands = &th0;
   87 struct timecounter *timecounter = &dummy_timecounter;
   88 static struct timecounter *timecounters = &dummy_timecounter;
   89 
   90 int tc_min_ticktock_freq = 1;
   91 
   92 time_t time_second = 1;
   93 time_t time_uptime = 1;
   94 
   95 struct bintime boottimebin;
   96 struct timeval boottime;
   97 static int sysctl_kern_boottime(SYSCTL_HANDLER_ARGS);
   98 SYSCTL_PROC(_kern, KERN_BOOTTIME, boottime, CTLTYPE_STRUCT|CTLFLAG_RD,
   99     NULL, 0, sysctl_kern_boottime, "S,timeval", "System boottime");
  100 
  101 SYSCTL_NODE(_kern, OID_AUTO, timecounter, CTLFLAG_RW, 0, "");
  102 SYSCTL_NODE(_kern_timecounter, OID_AUTO, tc, CTLFLAG_RW, 0, "");
  103 
  104 static int timestepwarnings;
  105 SYSCTL_INT(_kern_timecounter, OID_AUTO, stepwarnings, CTLFLAG_RW,
  106     &timestepwarnings, 0, "Log time steps");
  107 
  108 static void tc_windup(void);
  109 static void cpu_tick_calibrate(int);
  110 
  111 static int
  112 sysctl_kern_boottime(SYSCTL_HANDLER_ARGS)
  113 {
  114 #ifdef SCTL_MASK32
  115         int tv[2];
  116 
  117         if (req->flags & SCTL_MASK32) {
  118                 tv[0] = boottime.tv_sec;
  119                 tv[1] = boottime.tv_usec;
  120                 return SYSCTL_OUT(req, tv, sizeof(tv));
  121         } else
  122 #endif
  123                 return SYSCTL_OUT(req, &boottime, sizeof(boottime));
  124 }
  125 
  126 static int
  127 sysctl_kern_timecounter_get(SYSCTL_HANDLER_ARGS)
  128 {
  129         u_int ncount;
  130         struct timecounter *tc = arg1;
  131 
  132         ncount = tc->tc_get_timecount(tc);
  133         return sysctl_handle_int(oidp, &ncount, 0, req);
  134 }
  135 
  136 static int
  137 sysctl_kern_timecounter_freq(SYSCTL_HANDLER_ARGS)
  138 {
  139         uint64_t freq;
  140         struct timecounter *tc = arg1;
  141 
  142         freq = tc->tc_frequency;
  143         return sysctl_handle_64(oidp, &freq, 0, req);
  144 }
  145 
  146 /*
  147  * Return the difference between the timehands' counter value now and what
  148  * was when we copied it to the timehands' offset_count.
  149  */
  150 static __inline u_int
  151 tc_delta(struct timehands *th)
  152 {
  153         struct timecounter *tc;
  154 
  155         tc = th->th_counter;
  156         return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
  157             tc->tc_counter_mask);
  158 }
  159 
  160 /*
  161  * Functions for reading the time.  We have to loop until we are sure that
  162  * the timehands that we operated on was not updated under our feet.  See
  163  * the comment in <sys/time.h> for a description of these 12 functions.
  164  */
  165 
  166 void
  167 binuptime(struct bintime *bt)
  168 {
  169         struct timehands *th;
  170         u_int gen;
  171 
  172         do {
  173                 th = timehands;
  174                 gen = th->th_generation;
  175                 *bt = th->th_offset;
  176                 bintime_addx(bt, th->th_scale * tc_delta(th));
  177         } while (gen == 0 || gen != th->th_generation);
  178 }
  179 
  180 void
  181 nanouptime(struct timespec *tsp)
  182 {
  183         struct bintime bt;
  184 
  185         binuptime(&bt);
  186         bintime2timespec(&bt, tsp);
  187 }
  188 
  189 void
  190 microuptime(struct timeval *tvp)
  191 {
  192         struct bintime bt;
  193 
  194         binuptime(&bt);
  195         bintime2timeval(&bt, tvp);
  196 }
  197 
  198 void
  199 bintime(struct bintime *bt)
  200 {
  201 
  202         binuptime(bt);
  203         bintime_add(bt, &boottimebin);
  204 }
  205 
  206 void
  207 nanotime(struct timespec *tsp)
  208 {
  209         struct bintime bt;
  210 
  211         bintime(&bt);
  212         bintime2timespec(&bt, tsp);
  213 }
  214 
  215 void
  216 microtime(struct timeval *tvp)
  217 {
  218         struct bintime bt;
  219 
  220         bintime(&bt);
  221         bintime2timeval(&bt, tvp);
  222 }
  223 
  224 void
  225 getbinuptime(struct bintime *bt)
  226 {
  227         struct timehands *th;
  228         u_int gen;
  229 
  230         do {
  231                 th = timehands;
  232                 gen = th->th_generation;
  233                 *bt = th->th_offset;
  234         } while (gen == 0 || gen != th->th_generation);
  235 }
  236 
  237 void
  238 getnanouptime(struct timespec *tsp)
  239 {
  240         struct timehands *th;
  241         u_int gen;
  242 
  243         do {
  244                 th = timehands;
  245                 gen = th->th_generation;
  246                 bintime2timespec(&th->th_offset, tsp);
  247         } while (gen == 0 || gen != th->th_generation);
  248 }
  249 
  250 void
  251 getmicrouptime(struct timeval *tvp)
  252 {
  253         struct timehands *th;
  254         u_int gen;
  255 
  256         do {
  257                 th = timehands;
  258                 gen = th->th_generation;
  259                 bintime2timeval(&th->th_offset, tvp);
  260         } while (gen == 0 || gen != th->th_generation);
  261 }
  262 
  263 void
  264 getbintime(struct bintime *bt)
  265 {
  266         struct timehands *th;
  267         u_int gen;
  268 
  269         do {
  270                 th = timehands;
  271                 gen = th->th_generation;
  272                 *bt = th->th_offset;
  273         } while (gen == 0 || gen != th->th_generation);
  274         bintime_add(bt, &boottimebin);
  275 }
  276 
  277 void
  278 getnanotime(struct timespec *tsp)
  279 {
  280         struct timehands *th;
  281         u_int gen;
  282 
  283         do {
  284                 th = timehands;
  285                 gen = th->th_generation;
  286                 *tsp = th->th_nanotime;
  287         } while (gen == 0 || gen != th->th_generation);
  288 }
  289 
  290 void
  291 getmicrotime(struct timeval *tvp)
  292 {
  293         struct timehands *th;
  294         u_int gen;
  295 
  296         do {
  297                 th = timehands;
  298                 gen = th->th_generation;
  299                 *tvp = th->th_microtime;
  300         } while (gen == 0 || gen != th->th_generation);
  301 }
  302 
  303 /*
  304  * Initialize a new timecounter and possibly use it.
  305  */
  306 void
  307 tc_init(struct timecounter *tc)
  308 {
  309         u_int u;
  310         struct sysctl_oid *tc_root;
  311 
  312         u = tc->tc_frequency / tc->tc_counter_mask;
  313         /* XXX: We need some margin here, 10% is a guess */
  314         u *= 11;
  315         u /= 10;
  316         if (u > hz && tc->tc_quality >= 0) {
  317                 tc->tc_quality = -2000;
  318                 if (bootverbose) {
  319                         printf("Timecounter \"%s\" frequency %ju Hz",
  320                             tc->tc_name, (uintmax_t)tc->tc_frequency);
  321                         printf(" -- Insufficient hz, needs at least %u\n", u);
  322                 }
  323         } else if (tc->tc_quality >= 0 || bootverbose) {
  324                 printf("Timecounter \"%s\" frequency %ju Hz quality %d\n",
  325                     tc->tc_name, (uintmax_t)tc->tc_frequency,
  326                     tc->tc_quality);
  327         }
  328 
  329         tc->tc_next = timecounters;
  330         timecounters = tc;
  331         /*
  332          * Set up sysctl tree for this counter.
  333          */
  334         tc_root = SYSCTL_ADD_NODE(NULL,
  335             SYSCTL_STATIC_CHILDREN(_kern_timecounter_tc), OID_AUTO, tc->tc_name,
  336             CTLFLAG_RW, 0, "timecounter description");
  337         SYSCTL_ADD_UINT(NULL, SYSCTL_CHILDREN(tc_root), OID_AUTO,
  338             "mask", CTLFLAG_RD, &(tc->tc_counter_mask), 0,
  339             "mask for implemented bits");
  340         SYSCTL_ADD_PROC(NULL, SYSCTL_CHILDREN(tc_root), OID_AUTO,
  341             "counter", CTLTYPE_UINT | CTLFLAG_RD, tc, sizeof(*tc),
  342             sysctl_kern_timecounter_get, "IU", "current timecounter value");
  343         SYSCTL_ADD_PROC(NULL, SYSCTL_CHILDREN(tc_root), OID_AUTO,
  344             "frequency", CTLTYPE_U64 | CTLFLAG_RD, tc, sizeof(*tc),
  345              sysctl_kern_timecounter_freq, "QU", "timecounter frequency");
  346         SYSCTL_ADD_INT(NULL, SYSCTL_CHILDREN(tc_root), OID_AUTO,
  347             "quality", CTLFLAG_RD, &(tc->tc_quality), 0,
  348             "goodness of time counter");
  349         /*
  350          * Never automatically use a timecounter with negative quality.
  351          * Even though we run on the dummy counter, switching here may be
  352          * worse since this timecounter may not be monotonous.
  353          */
  354         if (tc->tc_quality < 0)
  355                 return;
  356         if (tc->tc_quality < timecounter->tc_quality)
  357                 return;
  358         if (tc->tc_quality == timecounter->tc_quality &&
  359             tc->tc_frequency < timecounter->tc_frequency)
  360                 return;
  361         (void)tc->tc_get_timecount(tc);
  362         (void)tc->tc_get_timecount(tc);
  363         timecounter = tc;
  364 }
  365 
  366 /* Report the frequency of the current timecounter. */
  367 uint64_t
  368 tc_getfrequency(void)
  369 {
  370 
  371         return (timehands->th_counter->tc_frequency);
  372 }
  373 
  374 /*
  375  * Step our concept of UTC.  This is done by modifying our estimate of
  376  * when we booted.
  377  * XXX: not locked.
  378  */
  379 void
  380 tc_setclock(struct timespec *ts)
  381 {
  382         struct timespec tbef, taft;
  383         struct bintime bt, bt2;
  384 
  385         cpu_tick_calibrate(1);
  386         nanotime(&tbef);
  387         timespec2bintime(ts, &bt);
  388         binuptime(&bt2);
  389         bintime_sub(&bt, &bt2);
  390         bintime_add(&bt2, &boottimebin);
  391         boottimebin = bt;
  392         bintime2timeval(&bt, &boottime);
  393 
  394         /* XXX fiddle all the little crinkly bits around the fiords... */
  395         tc_windup();
  396         nanotime(&taft);
  397         if (timestepwarnings) {
  398                 log(LOG_INFO,
  399                     "Time stepped from %jd.%09ld to %jd.%09ld (%jd.%09ld)\n",
  400                     (intmax_t)tbef.tv_sec, tbef.tv_nsec,
  401                     (intmax_t)taft.tv_sec, taft.tv_nsec,
  402                     (intmax_t)ts->tv_sec, ts->tv_nsec);
  403         }
  404         cpu_tick_calibrate(1);
  405 }
  406 
  407 /*
  408  * Initialize the next struct timehands in the ring and make
  409  * it the active timehands.  Along the way we might switch to a different
  410  * timecounter and/or do seconds processing in NTP.  Slightly magic.
  411  */
  412 static void
  413 tc_windup(void)
  414 {
  415         struct bintime bt;
  416         struct timehands *th, *tho;
  417         uint64_t scale;
  418         u_int delta, ncount, ogen;
  419         int i;
  420         time_t t;
  421 
  422         /*
  423          * Make the next timehands a copy of the current one, but do not
  424          * overwrite the generation or next pointer.  While we update
  425          * the contents, the generation must be zero.
  426          */
  427         tho = timehands;
  428         th = tho->th_next;
  429         ogen = th->th_generation;
  430         th->th_generation = 0;
  431         bcopy(tho, th, offsetof(struct timehands, th_generation));
  432 
  433         /*
  434          * Capture a timecounter delta on the current timecounter and if
  435          * changing timecounters, a counter value from the new timecounter.
  436          * Update the offset fields accordingly.
  437          */
  438         delta = tc_delta(th);
  439         if (th->th_counter != timecounter)
  440                 ncount = timecounter->tc_get_timecount(timecounter);
  441         else
  442                 ncount = 0;
  443         th->th_offset_count += delta;
  444         th->th_offset_count &= th->th_counter->tc_counter_mask;
  445         while (delta > th->th_counter->tc_frequency) {
  446                 /* Eat complete unadjusted seconds. */
  447                 delta -= th->th_counter->tc_frequency;
  448                 th->th_offset.sec++;
  449         }
  450         if ((delta > th->th_counter->tc_frequency / 2) &&
  451             (th->th_scale * delta < ((uint64_t)1 << 63))) {
  452                 /* The product th_scale * delta just barely overflows. */
  453                 th->th_offset.sec++;
  454         }
  455         bintime_addx(&th->th_offset, th->th_scale * delta);
  456 
  457         /*
  458          * Hardware latching timecounters may not generate interrupts on
  459          * PPS events, so instead we poll them.  There is a finite risk that
  460          * the hardware might capture a count which is later than the one we
  461          * got above, and therefore possibly in the next NTP second which might
  462          * have a different rate than the current NTP second.  It doesn't
  463          * matter in practice.
  464          */
  465         if (tho->th_counter->tc_poll_pps)
  466                 tho->th_counter->tc_poll_pps(tho->th_counter);
  467 
  468         /*
  469          * Deal with NTP second processing.  The for loop normally
  470          * iterates at most once, but in extreme situations it might
  471          * keep NTP sane if timeouts are not run for several seconds.
  472          * At boot, the time step can be large when the TOD hardware
  473          * has been read, so on really large steps, we call
  474          * ntp_update_second only twice.  We need to call it twice in
  475          * case we missed a leap second.
  476          */
  477         bt = th->th_offset;
  478         bintime_add(&bt, &boottimebin);
  479         i = bt.sec - tho->th_microtime.tv_sec;
  480         if (i > LARGE_STEP)
  481                 i = 2;
  482         for (; i > 0; i--) {
  483                 t = bt.sec;
  484                 ntp_update_second(&th->th_adjustment, &bt.sec);
  485                 if (bt.sec != t)
  486                         boottimebin.sec += bt.sec - t;
  487         }
  488         /* Update the UTC timestamps used by the get*() functions. */
  489         /* XXX shouldn't do this here.  Should force non-`get' versions. */
  490         bintime2timeval(&bt, &th->th_microtime);
  491         bintime2timespec(&bt, &th->th_nanotime);
  492 
  493         /* Now is a good time to change timecounters. */
  494         if (th->th_counter != timecounter) {
  495 #ifndef __arm__
  496                 if ((timecounter->tc_flags & TC_FLAGS_C3STOP) != 0)
  497                         cpu_disable_deep_sleep++;
  498                 if ((th->th_counter->tc_flags & TC_FLAGS_C3STOP) != 0)
  499                         cpu_disable_deep_sleep--;
  500 #endif
  501                 th->th_counter = timecounter;
  502                 th->th_offset_count = ncount;
  503                 tc_min_ticktock_freq = max(1, timecounter->tc_frequency /
  504                     (((uint64_t)timecounter->tc_counter_mask + 1) / 3));
  505         }
  506 
  507         /*-
  508          * Recalculate the scaling factor.  We want the number of 1/2^64
  509          * fractions of a second per period of the hardware counter, taking
  510          * into account the th_adjustment factor which the NTP PLL/adjtime(2)
  511          * processing provides us with.
  512          *
  513          * The th_adjustment is nanoseconds per second with 32 bit binary
  514          * fraction and we want 64 bit binary fraction of second:
  515          *
  516          *       x = a * 2^32 / 10^9 = a * 4.294967296
  517          *
  518          * The range of th_adjustment is +/- 5000PPM so inside a 64bit int
  519          * we can only multiply by about 850 without overflowing, that
  520          * leaves no suitably precise fractions for multiply before divide.
  521          *
  522          * Divide before multiply with a fraction of 2199/512 results in a
  523          * systematic undercompensation of 10PPM of th_adjustment.  On a
  524          * 5000PPM adjustment this is a 0.05PPM error.  This is acceptable.
  525          *
  526          * We happily sacrifice the lowest of the 64 bits of our result
  527          * to the goddess of code clarity.
  528          *
  529          */
  530         scale = (uint64_t)1 << 63;
  531         scale += (th->th_adjustment / 1024) * 2199;
  532         scale /= th->th_counter->tc_frequency;
  533         th->th_scale = scale * 2;
  534 
  535         /*
  536          * Now that the struct timehands is again consistent, set the new
  537          * generation number, making sure to not make it zero.
  538          */
  539         if (++ogen == 0)
  540                 ogen = 1;
  541         th->th_generation = ogen;
  542 
  543         /* Go live with the new struct timehands. */
  544         time_second = th->th_microtime.tv_sec;
  545         time_uptime = th->th_offset.sec;
  546         timehands = th;
  547 }
  548 
  549 /* Report or change the active timecounter hardware. */
  550 static int
  551 sysctl_kern_timecounter_hardware(SYSCTL_HANDLER_ARGS)
  552 {
  553         char newname[32];
  554         struct timecounter *newtc, *tc;
  555         int error;
  556 
  557         tc = timecounter;
  558         strlcpy(newname, tc->tc_name, sizeof(newname));
  559 
  560         error = sysctl_handle_string(oidp, &newname[0], sizeof(newname), req);
  561         if (error != 0 || req->newptr == NULL ||
  562             strcmp(newname, tc->tc_name) == 0)
  563                 return (error);
  564         for (newtc = timecounters; newtc != NULL; newtc = newtc->tc_next) {
  565                 if (strcmp(newname, newtc->tc_name) != 0)
  566                         continue;
  567 
  568                 /* Warm up new timecounter. */
  569                 (void)newtc->tc_get_timecount(newtc);
  570                 (void)newtc->tc_get_timecount(newtc);
  571 
  572                 timecounter = newtc;
  573                 return (0);
  574         }
  575         return (EINVAL);
  576 }
  577 
  578 SYSCTL_PROC(_kern_timecounter, OID_AUTO, hardware, CTLTYPE_STRING | CTLFLAG_RW,
  579     0, 0, sysctl_kern_timecounter_hardware, "A",
  580     "Timecounter hardware selected");
  581 
  582 
  583 /* Report or change the active timecounter hardware. */
  584 static int
  585 sysctl_kern_timecounter_choice(SYSCTL_HANDLER_ARGS)
  586 {
  587         char buf[32], *spc;
  588         struct timecounter *tc;
  589         int error;
  590 
  591         spc = "";
  592         error = 0;
  593         for (tc = timecounters; error == 0 && tc != NULL; tc = tc->tc_next) {
  594                 sprintf(buf, "%s%s(%d)",
  595                     spc, tc->tc_name, tc->tc_quality);
  596                 error = SYSCTL_OUT(req, buf, strlen(buf));
  597                 spc = " ";
  598         }
  599         return (error);
  600 }
  601 
  602 SYSCTL_PROC(_kern_timecounter, OID_AUTO, choice, CTLTYPE_STRING | CTLFLAG_RD,
  603     0, 0, sysctl_kern_timecounter_choice, "A", "Timecounter hardware detected");
  604 
  605 /*
  606  * RFC 2783 PPS-API implementation.
  607  */
  608 
  609 int
  610 pps_ioctl(u_long cmd, caddr_t data, struct pps_state *pps)
  611 {
  612         pps_params_t *app;
  613         struct pps_fetch_args *fapi;
  614 #ifdef PPS_SYNC
  615         struct pps_kcbind_args *kapi;
  616 #endif
  617 
  618         KASSERT(pps != NULL, ("NULL pps pointer in pps_ioctl"));
  619         switch (cmd) {
  620         case PPS_IOC_CREATE:
  621                 return (0);
  622         case PPS_IOC_DESTROY:
  623                 return (0);
  624         case PPS_IOC_SETPARAMS:
  625                 app = (pps_params_t *)data;
  626                 if (app->mode & ~pps->ppscap)
  627                         return (EINVAL);
  628                 pps->ppsparam = *app;
  629                 return (0);
  630         case PPS_IOC_GETPARAMS:
  631                 app = (pps_params_t *)data;
  632                 *app = pps->ppsparam;
  633                 app->api_version = PPS_API_VERS_1;
  634                 return (0);
  635         case PPS_IOC_GETCAP:
  636                 *(int*)data = pps->ppscap;
  637                 return (0);
  638         case PPS_IOC_FETCH:
  639                 fapi = (struct pps_fetch_args *)data;
  640                 if (fapi->tsformat && fapi->tsformat != PPS_TSFMT_TSPEC)
  641                         return (EINVAL);
  642                 if (fapi->timeout.tv_sec || fapi->timeout.tv_nsec)
  643                         return (EOPNOTSUPP);
  644                 pps->ppsinfo.current_mode = pps->ppsparam.mode;
  645                 fapi->pps_info_buf = pps->ppsinfo;
  646                 return (0);
  647         case PPS_IOC_KCBIND:
  648 #ifdef PPS_SYNC
  649                 kapi = (struct pps_kcbind_args *)data;
  650                 /* XXX Only root should be able to do this */
  651                 if (kapi->tsformat && kapi->tsformat != PPS_TSFMT_TSPEC)
  652                         return (EINVAL);
  653                 if (kapi->kernel_consumer != PPS_KC_HARDPPS)
  654                         return (EINVAL);
  655                 if (kapi->edge & ~pps->ppscap)
  656                         return (EINVAL);
  657                 pps->kcmode = kapi->edge;
  658                 return (0);
  659 #else
  660                 return (EOPNOTSUPP);
  661 #endif
  662         default:
  663                 return (ENOIOCTL);
  664         }
  665 }
  666 
  667 void
  668 pps_init(struct pps_state *pps)
  669 {
  670         pps->ppscap |= PPS_TSFMT_TSPEC;
  671         if (pps->ppscap & PPS_CAPTUREASSERT)
  672                 pps->ppscap |= PPS_OFFSETASSERT;
  673         if (pps->ppscap & PPS_CAPTURECLEAR)
  674                 pps->ppscap |= PPS_OFFSETCLEAR;
  675 }
  676 
  677 void
  678 pps_capture(struct pps_state *pps)
  679 {
  680         struct timehands *th;
  681 
  682         KASSERT(pps != NULL, ("NULL pps pointer in pps_capture"));
  683         th = timehands;
  684         pps->capgen = th->th_generation;
  685         pps->capth = th;
  686         pps->capcount = th->th_counter->tc_get_timecount(th->th_counter);
  687         if (pps->capgen != th->th_generation)
  688                 pps->capgen = 0;
  689 }
  690 
  691 void
  692 pps_event(struct pps_state *pps, int event)
  693 {
  694         struct bintime bt;
  695         struct timespec ts, *tsp, *osp;
  696         u_int tcount, *pcount;
  697         int foff, fhard;
  698         pps_seq_t *pseq;
  699 
  700         KASSERT(pps != NULL, ("NULL pps pointer in pps_event"));
  701         /* If the timecounter was wound up underneath us, bail out. */
  702         if (pps->capgen == 0 || pps->capgen != pps->capth->th_generation)
  703                 return;
  704 
  705         /* Things would be easier with arrays. */
  706         if (event == PPS_CAPTUREASSERT) {
  707                 tsp = &pps->ppsinfo.assert_timestamp;
  708                 osp = &pps->ppsparam.assert_offset;
  709                 foff = pps->ppsparam.mode & PPS_OFFSETASSERT;
  710                 fhard = pps->kcmode & PPS_CAPTUREASSERT;
  711                 pcount = &pps->ppscount[0];
  712                 pseq = &pps->ppsinfo.assert_sequence;
  713         } else {
  714                 tsp = &pps->ppsinfo.clear_timestamp;
  715                 osp = &pps->ppsparam.clear_offset;
  716                 foff = pps->ppsparam.mode & PPS_OFFSETCLEAR;
  717                 fhard = pps->kcmode & PPS_CAPTURECLEAR;
  718                 pcount = &pps->ppscount[1];
  719                 pseq = &pps->ppsinfo.clear_sequence;
  720         }
  721 
  722         /*
  723          * If the timecounter changed, we cannot compare the count values, so
  724          * we have to drop the rest of the PPS-stuff until the next event.
  725          */
  726         if (pps->ppstc != pps->capth->th_counter) {
  727                 pps->ppstc = pps->capth->th_counter;
  728                 *pcount = pps->capcount;
  729                 pps->ppscount[2] = pps->capcount;
  730                 return;
  731         }
  732 
  733         /* Convert the count to a timespec. */
  734         tcount = pps->capcount - pps->capth->th_offset_count;
  735         tcount &= pps->capth->th_counter->tc_counter_mask;
  736         bt = pps->capth->th_offset;
  737         bintime_addx(&bt, pps->capth->th_scale * tcount);
  738         bintime_add(&bt, &boottimebin);
  739         bintime2timespec(&bt, &ts);
  740 
  741         /* If the timecounter was wound up underneath us, bail out. */
  742         if (pps->capgen != pps->capth->th_generation)
  743                 return;
  744 
  745         *pcount = pps->capcount;
  746         (*pseq)++;
  747         *tsp = ts;
  748 
  749         if (foff) {
  750                 timespecadd(tsp, osp);
  751                 if (tsp->tv_nsec < 0) {
  752                         tsp->tv_nsec += 1000000000;
  753                         tsp->tv_sec -= 1;
  754                 }
  755         }
  756 #ifdef PPS_SYNC
  757         if (fhard) {
  758                 uint64_t scale;
  759 
  760                 /*
  761                  * Feed the NTP PLL/FLL.
  762                  * The FLL wants to know how many (hardware) nanoseconds
  763                  * elapsed since the previous event.
  764                  */
  765                 tcount = pps->capcount - pps->ppscount[2];
  766                 pps->ppscount[2] = pps->capcount;
  767                 tcount &= pps->capth->th_counter->tc_counter_mask;
  768                 scale = (uint64_t)1 << 63;
  769                 scale /= pps->capth->th_counter->tc_frequency;
  770                 scale *= 2;
  771                 bt.sec = 0;
  772                 bt.frac = 0;
  773                 bintime_addx(&bt, scale * tcount);
  774                 bintime2timespec(&bt, &ts);
  775                 hardpps(tsp, ts.tv_nsec + 1000000000 * ts.tv_sec);
  776         }
  777 #endif
  778 }
  779 
  780 /*
  781  * Timecounters need to be updated every so often to prevent the hardware
  782  * counter from overflowing.  Updating also recalculates the cached values
  783  * used by the get*() family of functions, so their precision depends on
  784  * the update frequency.
  785  */
  786 
  787 static int tc_tick;
  788 SYSCTL_INT(_kern_timecounter, OID_AUTO, tick, CTLFLAG_RD, &tc_tick, 0,
  789     "Approximate number of hardclock ticks in a millisecond");
  790 
  791 void
  792 tc_ticktock(int cnt)
  793 {
  794         static int count;
  795 
  796         count += cnt;
  797         if (count < tc_tick)
  798                 return;
  799         count = 0;
  800         tc_windup();
  801 }
  802 
  803 static void
  804 inittimecounter(void *dummy)
  805 {
  806         u_int p;
  807 
  808         /*
  809          * Set the initial timeout to
  810          * max(1, <approx. number of hardclock ticks in a millisecond>).
  811          * People should probably not use the sysctl to set the timeout
  812          * to smaller than its inital value, since that value is the
  813          * smallest reasonable one.  If they want better timestamps they
  814          * should use the non-"get"* functions.
  815          */
  816         if (hz > 1000)
  817                 tc_tick = (hz + 500) / 1000;
  818         else
  819                 tc_tick = 1;
  820         p = (tc_tick * 1000000) / hz;
  821         printf("Timecounters tick every %d.%03u msec\n", p / 1000, p % 1000);
  822 
  823         /* warm up new timecounter (again) and get rolling. */
  824         (void)timecounter->tc_get_timecount(timecounter);
  825         (void)timecounter->tc_get_timecount(timecounter);
  826         tc_windup();
  827 }
  828 
  829 SYSINIT(timecounter, SI_SUB_CLOCKS, SI_ORDER_SECOND, inittimecounter, NULL);
  830 
  831 /* Cpu tick handling -------------------------------------------------*/
  832 
  833 static int cpu_tick_variable;
  834 static uint64_t cpu_tick_frequency;
  835 
  836 static uint64_t
  837 tc_cpu_ticks(void)
  838 {
  839         static uint64_t base;
  840         static unsigned last;
  841         unsigned u;
  842         struct timecounter *tc;
  843 
  844         tc = timehands->th_counter;
  845         u = tc->tc_get_timecount(tc) & tc->tc_counter_mask;
  846         if (u < last)
  847                 base += (uint64_t)tc->tc_counter_mask + 1;
  848         last = u;
  849         return (u + base);
  850 }
  851 
  852 void
  853 cpu_tick_calibration(void)
  854 {
  855         static time_t last_calib;
  856 
  857         if (time_uptime != last_calib && !(time_uptime & 0xf)) {
  858                 cpu_tick_calibrate(0);
  859                 last_calib = time_uptime;
  860         }
  861 }
  862 
  863 /*
  864  * This function gets called every 16 seconds on only one designated
  865  * CPU in the system from hardclock() via cpu_tick_calibration()().
  866  *
  867  * Whenever the real time clock is stepped we get called with reset=1
  868  * to make sure we handle suspend/resume and similar events correctly.
  869  */
  870 
  871 static void
  872 cpu_tick_calibrate(int reset)
  873 {
  874         static uint64_t c_last;
  875         uint64_t c_this, c_delta;
  876         static struct bintime  t_last;
  877         struct bintime t_this, t_delta;
  878         uint32_t divi;
  879 
  880         if (reset) {
  881                 /* The clock was stepped, abort & reset */
  882                 t_last.sec = 0;
  883                 return;
  884         }
  885 
  886         /* we don't calibrate fixed rate cputicks */
  887         if (!cpu_tick_variable)
  888                 return;
  889 
  890         getbinuptime(&t_this);
  891         c_this = cpu_ticks();
  892         if (t_last.sec != 0) {
  893                 c_delta = c_this - c_last;
  894                 t_delta = t_this;
  895                 bintime_sub(&t_delta, &t_last);
  896                 /*
  897                  * Headroom:
  898                  *      2^(64-20) / 16[s] =
  899                  *      2^(44) / 16[s] =
  900                  *      17.592.186.044.416 / 16 =
  901                  *      1.099.511.627.776 [Hz]
  902                  */
  903                 divi = t_delta.sec << 20;
  904                 divi |= t_delta.frac >> (64 - 20);
  905                 c_delta <<= 20;
  906                 c_delta /= divi;
  907                 if (c_delta > cpu_tick_frequency) {
  908                         if (0 && bootverbose)
  909                                 printf("cpu_tick increased to %ju Hz\n",
  910                                     c_delta);
  911                         cpu_tick_frequency = c_delta;
  912                 }
  913         }
  914         c_last = c_this;
  915         t_last = t_this;
  916 }
  917 
  918 void
  919 set_cputicker(cpu_tick_f *func, uint64_t freq, unsigned var)
  920 {
  921 
  922         if (func == NULL) {
  923                 cpu_ticks = tc_cpu_ticks;
  924         } else {
  925                 cpu_tick_frequency = freq;
  926                 cpu_tick_variable = var;
  927                 cpu_ticks = func;
  928         }
  929 }
  930 
  931 uint64_t
  932 cpu_tickrate(void)
  933 {
  934 
  935         if (cpu_ticks == tc_cpu_ticks) 
  936                 return (tc_getfrequency());
  937         return (cpu_tick_frequency);
  938 }
  939 
  940 /*
  941  * We need to be slightly careful converting cputicks to microseconds.
  942  * There is plenty of margin in 64 bits of microseconds (half a million
  943  * years) and in 64 bits at 4 GHz (146 years), but if we do a multiply
  944  * before divide conversion (to retain precision) we find that the
  945  * margin shrinks to 1.5 hours (one millionth of 146y).
  946  * With a three prong approach we never lose significant bits, no
  947  * matter what the cputick rate and length of timeinterval is.
  948  */
  949 
  950 uint64_t
  951 cputick2usec(uint64_t tick)
  952 {
  953 
  954         if (tick > 18446744073709551LL)         /* floor(2^64 / 1000) */
  955                 return (tick / (cpu_tickrate() / 1000000LL));
  956         else if (tick > 18446744073709LL)       /* floor(2^64 / 1000000) */
  957                 return ((tick * 1000LL) / (cpu_tickrate() / 1000LL));
  958         else
  959                 return ((tick * 1000000LL) / cpu_tickrate());
  960 }
  961 
  962 cpu_tick_f      *cpu_ticks = tc_cpu_ticks;

Cache object: e3b4b65ae62a290492b84f1384de54c0


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.