tools/testing/selftests/timers/adjtick.c

   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 #ifdef KTEST
  27 #include "../kselftest.h"
  28 #else
  29 static inline int ksft_exit_pass(void)
  30 {
  31         exit(0);
  32 }
  33 static inline int ksft_exit_fail(void)
  34 {
  35         exit(1);
  36 }
  37 #endif
  38
  39 #define CLOCK_MONOTONIC_RAW     4
  40
  41 #define NSEC_PER_SEC            1000000000LL
  42 #define USEC_PER_SEC            1000000
  43
  44 #define MILLION                 1000000
  45
  46 long systick;
  47
  48 long long llabs(long long val)
  49 {
  50         if (val < 0)
  51                 val = -val;
  52         return val;
  53 }
  54
  55 unsigned long long ts_to_nsec(struct timespec ts)
  56 {
  57         return ts.tv_sec * NSEC_PER_SEC + ts.tv_nsec;
  58 }
  59
  60 struct timespec nsec_to_ts(long long ns)
  61 {
  62         struct timespec ts;
  63
  64         ts.tv_sec = ns/NSEC_PER_SEC;
  65         ts.tv_nsec = ns%NSEC_PER_SEC;
  66
  67         return ts;
  68 }
  69
  70 long long diff_timespec(struct timespec start, struct timespec end)
  71 {
  72         long long start_ns, end_ns;
  73
  74         start_ns = ts_to_nsec(start);
  75         end_ns = ts_to_nsec(end);
  76
  77         return end_ns - start_ns;
  78 }
  79
  80 void get_monotonic_and_raw(struct timespec *mon, struct timespec *raw)
  81 {
  82         struct timespec start, mid, end;
  83         long long diff = 0, tmp;
  84         int i;
  85
  86         clock_gettime(CLOCK_MONOTONIC, mon);
  87         clock_gettime(CLOCK_MONOTONIC_RAW, raw);
  88
  89         /* Try to get a more tightly bound pairing */
  90         for (i = 0; i < 3; i++) {
  91                 long long newdiff;
  92
  93                 clock_gettime(CLOCK_MONOTONIC, &start);
  94                 clock_gettime(CLOCK_MONOTONIC_RAW, &mid);
  95                 clock_gettime(CLOCK_MONOTONIC, &end);
  96
  97                 newdiff = diff_timespec(start, end);
  98                 if (diff == 0 || newdiff < diff) {
  99                         diff = newdiff;
 100                         *raw = mid;
 101                         tmp = (ts_to_nsec(start) + ts_to_nsec(end))/2;
 102                         *mon = nsec_to_ts(tmp);
 103                 }
 104         }
 105 }
 106
 107 long long get_ppm_drift(void)
 108 {
 109         struct timespec mon_start, raw_start, mon_end, raw_end;
 110         long long delta1, delta2, eppm;
 111
 112         get_monotonic_and_raw(&mon_start, &raw_start);
 113
 114         sleep(15);
 115
 116         get_monotonic_and_raw(&mon_end, &raw_end);
 117
 118         delta1 = diff_timespec(mon_start, mon_end);
 119         delta2 = diff_timespec(raw_start, raw_end);
 120
 121         eppm = (delta1*MILLION)/delta2 - MILLION;
 122
 123         return eppm;
 124 }
 125
 126 int check_tick_adj(long tickval)
 127 {
 128         long long eppm, ppm;
 129         struct timex tx1;
 130
 131         tx1.modes        = ADJ_TICK;
 132         tx1.modes       |= ADJ_OFFSET;
 133         tx1.modes       |= ADJ_FREQUENCY;
 134         tx1.modes       |= ADJ_STATUS;
 135
 136         tx1.status      = STA_PLL;
 137         tx1.offset      = 0;
 138         tx1.freq        = 0;
 139         tx1.tick        = tickval;
 140
 141         adjtimex(&tx1);
 142
 143         sleep(1);
 144
 145         ppm = ((long long)tickval * MILLION)/systick - MILLION;
 146         printf("Estimating tick (act: %ld usec, %lld ppm): ", tickval, ppm);
 147
 148         eppm = get_ppm_drift();
 149         printf("%lld usec, %lld ppm", systick + (systick * eppm / MILLION), eppm);
 150
 151         tx1.modes = 0;
 152         adjtimex(&tx1);
 153
 154         if (tx1.offset || tx1.freq || tx1.tick != tickval) {
 155                 printf("        [ERROR]\n");
 156                 printf("\tUnexpected adjtimex return values, make sure ntpd is not running.\n");
 157                 return -1;
 158         }
 159
 160         /*
 161          * Here we use 100ppm difference as an error bound.
 162          * We likely should see better, but some coarse clocksources
 163          * cannot match the HZ tick size accurately, so we have a
 164          * internal correction factor that doesn't scale exactly
 165          * with the adjustment, resulting in > 10ppm error during
 166          * a 10% adjustment. 100ppm also gives us more breathing
 167          * room for interruptions during the measurement.
 168          */
 169         if (llabs(eppm - ppm) > 100) {
 170                 printf("        [FAILED]\n");
 171                 return -1;
 172         }
 173         printf("        [OK]\n");
 174
 175         return  0;
 176 }
 177
 178 int main(int argv, char **argc)
 179 {
 180         struct timespec raw;
 181         long tick, max, interval, err;
 182         struct timex tx1;
 183
 184         err = 0;
 185         setbuf(stdout, NULL);
 186
 187         if (clock_gettime(CLOCK_MONOTONIC_RAW, &raw)) {
 188                 printf("ERR: NO CLOCK_MONOTONIC_RAW\n");
 189                 return -1;
 190         }
 191
 192         printf("Each iteration takes about 15 seconds\n");
 193
 194         systick = sysconf(_SC_CLK_TCK);
 195         systick = USEC_PER_SEC/sysconf(_SC_CLK_TCK);
 196         max = systick/10; /* +/- 10% */
 197         interval = max/4; /* in 4 steps each side */
 198
 199         for (tick = (systick - max); tick < (systick + max); tick += interval) {
 200                 if (check_tick_adj(tick)) {
 201                         err = 1;
 202                         break;
 203                 }
 204         }
 205
 206         /* Reset things to zero */
 207         tx1.modes        = ADJ_TICK;
 208         tx1.modes       |= ADJ_OFFSET;
 209         tx1.modes       |= ADJ_FREQUENCY;
 210
 211         tx1.offset       = 0;
 212         tx1.freq         = 0;
 213         tx1.tick         = systick;
 214
 215         adjtimex(&tx1);
 216
 217         if (err)
 218                 return ksft_exit_fail();
 219
 220         return ksft_exit_pass();
 221 }