root/tools/testing/selftests/timers/adjtick.c

DEFINITIONS

1. llabs
2. ts_to_nsec
3. nsec_to_ts
4. diff_timespec
5. get_monotonic_and_raw
6. get_ppm_drift
7. check_tick_adj
8. main

   1 /* adjtimex() tick adjustment test
   2  *              by:   John Stultz <john.stultz@linaro.org>
   3  *              (C) Copyright Linaro Limited 2015
   4  *              Licensed under the GPLv2
   5  *
   6  *  To build:
   7  *      $ gcc adjtick.c -o adjtick -lrt
   8  *
   9  *   This program is free software: you can redistribute it and/or modify
  10  *   it under the terms of the GNU General Public License as published by
  11  *   the Free Software Foundation, either version 2 of the License, or
  12  *   (at your option) any later version.
  13  *
  14  *   This program is distributed in the hope that it will be useful,
  15  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *   GNU General Public License for more details.
  18  */
  19 #include <stdio.h>
  20 #include <unistd.h>
  21 #include <stdlib.h>
  22 #include <sys/time.h>
  23 #include <sys/timex.h>
  24 #include <time.h>
  25 
  26 #include "../kselftest.h"
  27 
  28 #define CLOCK_MONOTONIC_RAW     4
  29 
  30 #define NSEC_PER_SEC            1000000000LL
  31 #define USEC_PER_SEC            1000000
  32 
  33 #define MILLION                 1000000
  34 
  35 long systick;
  36 
  37 long long llabs(long long val)
  38 {
  39         if (val < 0)
  40                 val = -val;
  41         return val;
  42 }
  43 
  44 unsigned long long ts_to_nsec(struct timespec ts)
  45 {
  46         return ts.tv_sec * NSEC_PER_SEC + ts.tv_nsec;
  47 }
  48 
  49 struct timespec nsec_to_ts(long long ns)
  50 {
  51         struct timespec ts;
  52 
  53         ts.tv_sec = ns/NSEC_PER_SEC;
  54         ts.tv_nsec = ns%NSEC_PER_SEC;
  55 
  56         return ts;
  57 }
  58 
  59 long long diff_timespec(struct timespec start, struct timespec end)
  60 {
  61         long long start_ns, end_ns;
  62 
  63         start_ns = ts_to_nsec(start);
  64         end_ns = ts_to_nsec(end);
  65 
  66         return end_ns - start_ns;
  67 }
  68 
  69 void get_monotonic_and_raw(struct timespec *mon, struct timespec *raw)
  70 {
  71         struct timespec start, mid, end;
  72         long long diff = 0, tmp;
  73         int i;
  74 
  75         clock_gettime(CLOCK_MONOTONIC, mon);
  76         clock_gettime(CLOCK_MONOTONIC_RAW, raw);
  77 
  78         /* Try to get a more tightly bound pairing */
  79         for (i = 0; i < 3; i++) {
  80                 long long newdiff;
  81 
  82                 clock_gettime(CLOCK_MONOTONIC, &start);
  83                 clock_gettime(CLOCK_MONOTONIC_RAW, &mid);
  84                 clock_gettime(CLOCK_MONOTONIC, &end);
  85 
  86                 newdiff = diff_timespec(start, end);
  87                 if (diff == 0 || newdiff < diff) {
  88                         diff = newdiff;
  89                         *raw = mid;
  90                         tmp = (ts_to_nsec(start) + ts_to_nsec(end))/2;
  91                         *mon = nsec_to_ts(tmp);
  92                 }
  93         }
  94 }
  95 
  96 long long get_ppm_drift(void)
  97 {
  98         struct timespec mon_start, raw_start, mon_end, raw_end;
  99         long long delta1, delta2, eppm;
 100 
 101         get_monotonic_and_raw(&mon_start, &raw_start);
 102 
 103         sleep(15);
 104 
 105         get_monotonic_and_raw(&mon_end, &raw_end);
 106 
 107         delta1 = diff_timespec(mon_start, mon_end);
 108         delta2 = diff_timespec(raw_start, raw_end);
 109 
 110         eppm = (delta1*MILLION)/delta2 - MILLION;
 111 
 112         return eppm;
 113 }
 114 
 115 int check_tick_adj(long tickval)
 116 {
 117         long long eppm, ppm;
 118         struct timex tx1;
 119 
 120         tx1.modes        = ADJ_TICK;
 121         tx1.modes       |= ADJ_OFFSET;
 122         tx1.modes       |= ADJ_FREQUENCY;
 123         tx1.modes       |= ADJ_STATUS;
 124 
 125         tx1.status      = STA_PLL;
 126         tx1.offset      = 0;
 127         tx1.freq        = 0;
 128         tx1.tick        = tickval;
 129 
 130         adjtimex(&tx1);
 131 
 132         sleep(1);
 133 
 134         ppm = ((long long)tickval * MILLION)/systick - MILLION;
 135         printf("Estimating tick (act: %ld usec, %lld ppm): ", tickval, ppm);
 136 
 137         eppm = get_ppm_drift();
 138         printf("%lld usec, %lld ppm", systick + (systick * eppm / MILLION), eppm);
 139         fflush(stdout);
 140 
 141         tx1.modes = 0;
 142         adjtimex(&tx1);
 143 
 144         if (tx1.offset || tx1.freq || tx1.tick != tickval) {
 145                 printf("        [ERROR]\n");
 146                 printf("\tUnexpected adjtimex return values, make sure ntpd is not running.\n");
 147                 return -1;
 148         }
 149 
 150         /*
 151          * Here we use 100ppm difference as an error bound.
 152          * We likely should see better, but some coarse clocksources
 153          * cannot match the HZ tick size accurately, so we have a
 154          * internal correction factor that doesn't scale exactly
 155          * with the adjustment, resulting in > 10ppm error during
 156          * a 10% adjustment. 100ppm also gives us more breathing
 157          * room for interruptions during the measurement.
 158          */
 159         if (llabs(eppm - ppm) > 100) {
 160                 printf("        [FAILED]\n");
 161                 return -1;
 162         }
 163         printf("        [OK]\n");
 164 
 165         return  0;
 166 }
 167 
 168 int main(int argv, char **argc)
 169 {
 170         struct timespec raw;
 171         long tick, max, interval, err;
 172         struct timex tx1;
 173 
 174         err = 0;
 175         setbuf(stdout, NULL);
 176 
 177         if (clock_gettime(CLOCK_MONOTONIC_RAW, &raw)) {
 178                 printf("ERR: NO CLOCK_MONOTONIC_RAW\n");
 179                 return -1;
 180         }
 181 
 182         printf("Each iteration takes about 15 seconds\n");
 183 
 184         systick = sysconf(_SC_CLK_TCK);
 185         systick = USEC_PER_SEC/sysconf(_SC_CLK_TCK);
 186         max = systick/10; /* +/- 10% */
 187         interval = max/4; /* in 4 steps each side */
 188 
 189         for (tick = (systick - max); tick < (systick + max); tick += interval) {
 190                 if (check_tick_adj(tick)) {
 191                         err = 1;
 192                         break;
 193                 }
 194         }
 195 
 196         /* Reset things to zero */
 197         tx1.modes        = ADJ_TICK;
 198         tx1.modes       |= ADJ_OFFSET;
 199         tx1.modes       |= ADJ_FREQUENCY;
 200 
 201         tx1.offset       = 0;
 202         tx1.freq         = 0;
 203         tx1.tick         = systick;
 204 
 205         adjtimex(&tx1);
 206 
 207         if (err)
 208                 return ksft_exit_fail();
 209 
 210         return ksft_exit_pass();
 211 }