contrib/ntp/util/ntptime.c

   1 /*
   2  * NTP test program
   3  *
   4  * This program tests to see if the NTP user interface routines
   5  * ntp_gettime() and ntp_adjtime() have been implemented in the kernel.
   6  * If so, each of these routines is called to display current timekeeping
   7  * data.
   8  *
   9  * For more information, see the README.kern file in the doc directory
  10  * of the xntp3 distribution.
  11  */
  12
  13 #ifdef HAVE_CONFIG_H
  14 # include <config.h>
  15 #endif /* HAVE_CONFIG_H */
  16
  17 #include "ntp_fp.h"
  18 #include "timevalops.h"
  19 #include "ntp_syscall.h"
  20 #include "ntp_stdlib.h"
  21
  22 #include <stdio.h>
  23 #include <ctype.h>
  24 #include <signal.h>
  25 #include <setjmp.h>
  26
  27 #ifdef NTP_SYSCALLS_STD
  28 # ifndef SYS_DECOSF1
  29 #  define BADCALL -1            /* this is supposed to be a bad syscall */
  30 # endif /* SYS_DECOSF1 */
  31 #endif
  32
  33 #ifdef HAVE_STRUCT_NTPTIMEVAL_TIME_TV_NSEC
  34 #define tv_frac_sec tv_nsec
  35 #else
  36 #define tv_frac_sec tv_usec
  37 #endif
  38
  39
  40 #define TIMEX_MOD_BITS \
  41 "\20\1OFFSET\2FREQUENCY\3MAXERROR\4ESTERROR\5STATUS\6TIMECONST\
  42 \13PLL\14FLL\15MICRO\16NANO\17CLKB\20CLKA"
  43
  44 #define TIMEX_STA_BITS \
  45 "\20\1PLL\2PPSFREQ\3PPSTIME\4FLL\5INS\6DEL\7UNSYNC\10FREQHOLD\
  46 \11PPSSIGNAL\12PPSJITTER\13PPSWANDER\14PPSERROR\15CLOCKERR\
  47 \16NANO\17MODE\20CLK"
  48
  49 #define SCALE_FREQ 65536                /* frequency scale */
  50
  51 /*
  52  * These constants are used to round the time stamps computed from
  53  * a struct timeval to the microsecond (more or less).  This keeps
  54  * things neat.
  55  */
  56 #define TS_MASK         0xfffff000      /* mask to usec, for time stamps */
  57 #define TS_ROUNDBIT     0x00000800      /* round at this bit */
  58
  59 /*
  60  * Function prototypes
  61  */
  62 const char *    sprintb         (u_int, const char *);
  63 const char *    timex_state     (int);
  64
  65 #ifdef SIGSYS
  66 void pll_trap           (int);
  67
  68 static struct sigaction newsigsys;      /* new sigaction status */
  69 static struct sigaction sigsys;         /* current sigaction status */
  70 static sigjmp_buf env;          /* environment var. for pll_trap() */
  71 #endif
  72
  73 static volatile int pll_control; /* (0) daemon, (1) kernel loop */
  74 static volatile int status;     /* most recent status bits */
  75 static volatile int flash;      /* most recent ntp_adjtime() bits */
  76 char const * progname;
  77 static char optargs[] = "MNT:cde:f:hm:o:rs:t:";
  78
  79 int
  80 main(
  81         int argc,
  82         char *argv[]
  83         )
  84 {
  85         extern int ntp_optind;
  86         extern char *ntp_optarg;
  87 #ifdef SUBST_ADJTIMEX
  88         struct timex ntv;
  89 #else
  90         struct ntptimeval ntv;
  91 #endif
  92         struct timeval tv;
  93         struct timex ntx, _ntx;
  94         int     times[20] = { 0 };
  95         double ftemp, gtemp, htemp;
  96         long time_frac;                         /* ntv.time.tv_frac_sec (us/ns) */
  97         l_fp ts;
  98         volatile unsigned ts_mask = TS_MASK;            /* defaults to 20 bits (us) */
  99         volatile unsigned ts_roundbit = TS_ROUNDBIT;    /* defaults to 20 bits (us) */
 100         volatile int fdigits = 6;                       /* fractional digits for us */
 101         size_t c;
 102         int ch;
 103         int errflg      = 0;
 104         int cost        = 0;
 105         volatile int rawtime    = 0;
 106
 107         ZERO(ntx);
 108         progname = argv[0];
 109         while ((ch = ntp_getopt(argc, argv, optargs)) != EOF) {
 110                 switch (ch) {
 111 #ifdef MOD_MICRO
 112                 case 'M':
 113                         ntx.modes |= MOD_MICRO;
 114                         break;
 115 #endif
 116 #ifdef MOD_NANO
 117                 case 'N':
 118                         ntx.modes |= MOD_NANO;
 119                         break;
 120 #endif
 121 #ifdef NTP_API
 122 # if NTP_API > 3
 123                 case 'T':
 124                         ntx.modes = MOD_TAI;
 125                         ntx.constant = atoi(ntp_optarg);
 126                         break;
 127 # endif
 128 #endif
 129                 case 'c':
 130                         cost++;
 131                         break;
 132
 133                 case 'e':
 134                         ntx.modes |= MOD_ESTERROR;
 135                         ntx.esterror = atoi(ntp_optarg);
 136                         break;
 137
 138                 case 'f':
 139                         ntx.modes |= MOD_FREQUENCY;
 140                         ntx.freq = (long)(atof(ntp_optarg) * SCALE_FREQ);
 141                         break;
 142
 143                 case 'm':
 144                         ntx.modes |= MOD_MAXERROR;
 145                         ntx.maxerror = atoi(ntp_optarg);
 146                         break;
 147
 148                 case 'o':
 149                         ntx.modes |= MOD_OFFSET;
 150                         ntx.offset = atoi(ntp_optarg);
 151                         break;
 152
 153                 case 'r':
 154                         rawtime++;
 155                         break;
 156
 157                 case 's':
 158                         ntx.modes |= MOD_STATUS;
 159                         ntx.status = atoi(ntp_optarg);
 160                         if (ntx.status < 0 || ntx.status >= 0x100)
 161                                 errflg++;
 162                         break;
 163
 164                 case 't':
 165                         ntx.modes |= MOD_TIMECONST;
 166                         ntx.constant = atoi(ntp_optarg);
 167                         break;
 168
 169                 default:
 170                         errflg++;
 171                 }
 172         }
 173         if (errflg || (ntp_optind != argc)) {
 174                 fprintf(stderr,
 175                         "usage: %s [-%s]\n\n\
 176 %s%s%s\
 177 -c              display the time taken to call ntp_gettime (us)\n\
 178 -e esterror     estimate of the error (us)\n\
 179 -f frequency    Frequency error (-500 .. 500) (ppm)\n\
 180 -h              display this help info\n\
 181 -m maxerror     max possible error (us)\n\
 182 -o offset       current offset (ms)\n\
 183 -r              print the unix and NTP time raw\n\
 184 -s status       Set the status bits\n\
 185 -t timeconstant log2 of PLL time constant (0 .. %d)\n",
 186                         progname, optargs,
 187 #ifdef MOD_MICRO
 188 "-M             switch to microsecond mode\n",
 189 #else
 190 "",
 191 #endif
 192 #ifdef MOD_NANO
 193 "-N             switch to nanosecond mode\n",
 194 #else
 195 "",
 196 #endif
 197 #ifdef NTP_API
 198 # if NTP_API > 3
 199 "-T tai_offset  set TAI offset\n",
 200 # else
 201 "",
 202 # endif
 203 #else
 204 "",
 205 #endif
 206                         MAXTC);
 207                 exit(2);
 208         }
 209
 210 #ifdef SIGSYS
 211         /*
 212          * Test to make sure the sigaction() works in case of invalid
 213          * syscall codes.
 214          */
 215         newsigsys.sa_handler = pll_trap;
 216         newsigsys.sa_flags = 0;
 217         if (sigaction(SIGSYS, &newsigsys, &sigsys)) {
 218                 perror("sigaction() fails to save SIGSYS trap");
 219                 exit(1);
 220         }
 221 #endif /* SIGSYS */
 222
 223 #ifdef  BADCALL
 224         /*
 225          * Make sure the trapcatcher works.
 226          */
 227         pll_control = 1;
 228 #ifdef SIGSYS
 229         if (sigsetjmp(env, 1) == 0) {
 230 #endif
 231                 status = syscall(BADCALL, &ntv); /* dummy parameter */
 232                 if ((status < 0) && (errno == ENOSYS))
 233                         --pll_control;
 234 #ifdef SIGSYS
 235         }
 236 #endif
 237         if (pll_control)
 238             printf("sigaction() failed to catch an invalid syscall\n");
 239 #endif /* BADCALL */
 240
 241         if (cost) {
 242 #ifdef SIGSYS
 243                 if (sigsetjmp(env, 1) == 0) {
 244 #endif
 245                         for (c = 0; c < COUNTOF(times); c++) {
 246                                 status = ntp_gettime(&ntv);
 247                                 if ((status < 0) && (errno == ENOSYS))
 248                                         --pll_control;
 249                                 if (pll_control < 0)
 250                                         break;
 251                                 times[c] = ntv.time.tv_frac_sec;
 252                         }
 253 #ifdef SIGSYS
 254                 }
 255 #endif
 256                 if (pll_control >= 0) {
 257                         printf("[ us %06d:", times[0]);
 258                         for (c = 1; c < COUNTOF(times); c++)
 259                             printf(" %d", times[c] - times[c - 1]);
 260                         printf(" ]\n");
 261                 }
 262         }
 263 #ifdef SIGSYS
 264         if (sigsetjmp(env, 1) == 0) {
 265 #endif
 266                 status = ntp_gettime(&ntv);
 267                 if ((status < 0) && (errno == ENOSYS))
 268                         --pll_control;
 269 #ifdef SIGSYS
 270         }
 271 #endif
 272         _ntx.modes = 0;                         /* Ensure nothing is set */
 273 #ifdef SIGSYS
 274         if (sigsetjmp(env, 1) == 0) {
 275 #endif
 276                 status = ntp_adjtime(&_ntx);
 277                 if ((status < 0) && (errno == ENOSYS))
 278                         --pll_control;
 279                 flash = _ntx.status;
 280 #ifdef SIGSYS
 281         }
 282 #endif
 283         if (pll_control < 0) {
 284                 printf("NTP user interface routines are not configured in this kernel.\n");
 285                 goto lexit;
 286         }
 287
 288         /*
 289          * Fetch timekeeping data and display.
 290          */
 291         status = ntp_gettime(&ntv);
 292         if (status < 0) {
 293                 perror("ntp_gettime() call fails");
 294         } else {
 295                 printf("ntp_gettime() returns code %d (%s)\n",
 296                     status, timex_state(status));
 297                 time_frac = ntv.time.tv_frac_sec;
 298 #ifdef STA_NANO
 299                 if (flash & STA_NANO) {
 300                         ntv.time.tv_frac_sec /= 1000;
 301                         ts_mask = 0xfffffffc;   /* 1/2^30 */
 302                         ts_roundbit = 0x00000002;
 303                         fdigits = 9;
 304                 }
 305 #endif
 306                 tv.tv_sec = ntv.time.tv_sec;
 307                 tv.tv_usec = ntv.time.tv_frac_sec;
 308                 TVTOTS(&tv, &ts);
 309                 ts.l_ui += JAN_1970;
 310                 ts.l_uf += ts_roundbit;
 311                 ts.l_uf &= ts_mask;
 312                 printf("  time %s, (.%0*d),\n",
 313                        prettydate(&ts), fdigits, (int)time_frac);
 314                 printf("  maximum error %lu us, estimated error %lu us",
 315                        (u_long)ntv.maxerror, (u_long)ntv.esterror);
 316                 if (rawtime)
 317                         printf("  ntptime=%x.%x unixtime=%x.%0*d %s",
 318                                (u_int)ts.l_ui, (u_int)ts.l_uf,
 319                                (int)ntv.time.tv_sec, fdigits,
 320                                (int)time_frac,
 321                                ctime((time_t *)&ntv.time.tv_sec));
 322 #if NTP_API > 3
 323                 printf(", TAI offset %ld\n", (long)ntv.tai);
 324 #else
 325                 printf("\n");
 326 #endif /* NTP_API */
 327         }
 328         status = ntp_adjtime(&ntx);
 329         if (status < 0) {
 330                 perror((errno == EPERM) ?
 331                    "Must be root to set kernel values\nntp_adjtime() call fails" :
 332                    "ntp_adjtime() call fails");
 333         } else {
 334                 flash = ntx.status;
 335                 printf("ntp_adjtime() returns code %d (%s)\n",
 336                      status, timex_state(status));
 337                 printf("  modes %s,\n", sprintb(ntx.modes, TIMEX_MOD_BITS));
 338                 ftemp = (double)ntx.offset;
 339 #ifdef STA_NANO
 340                 if (flash & STA_NANO)
 341                         ftemp /= 1000.0;
 342 #endif
 343                 printf("  offset %.3f", ftemp);
 344                 ftemp = (double)ntx.freq / SCALE_FREQ;
 345                 printf(" us, frequency %.3f ppm, interval %d s,\n",
 346                      ftemp, 1 << ntx.shift);
 347                 printf("  maximum error %lu us, estimated error %lu us,\n",
 348                      (u_long)ntx.maxerror, (u_long)ntx.esterror);
 349                 printf("  status %s,\n", sprintb((u_int)ntx.status, TIMEX_STA_BITS));
 350                 ftemp = (double)ntx.tolerance / SCALE_FREQ;
 351                 gtemp = (double)ntx.precision;
 352 #ifdef STA_NANO
 353                 if (flash & STA_NANO)
 354                         gtemp /= 1000.0;
 355 #endif
 356                 printf(
 357                     "  time constant %lu, precision %.3f us, tolerance %.0f ppm,\n",
 358                     (u_long)ntx.constant, gtemp, ftemp);
 359                 if (ntx.shift == 0)
 360                         exit(0);
 361                 ftemp = (double)ntx.ppsfreq / SCALE_FREQ;
 362                 gtemp = (double)ntx.stabil / SCALE_FREQ;
 363                 htemp = (double)ntx.jitter;
 364 #ifdef STA_NANO
 365                 if (flash & STA_NANO)
 366                         htemp /= 1000.0;
 367 #endif
 368                 printf(
 369                     "  pps frequency %.3f ppm, stability %.3f ppm, jitter %.3f us,\n",
 370                     ftemp, gtemp, htemp);
 371                 printf("  intervals %lu, jitter exceeded %lu, stability exceeded %lu, errors %lu.\n",
 372                     (u_long)ntx.calcnt, (u_long)ntx.jitcnt,
 373                     (u_long)ntx.stbcnt, (u_long)ntx.errcnt);
 374                 return 0;
 375         }
 376
 377         /*
 378          * Put things back together the way we found them.
 379          */
 380     lexit:
 381 #ifdef SIGSYS
 382         if (sigaction(SIGSYS, &sigsys, (struct sigaction *)NULL)) {
 383                 perror("sigaction() fails to restore SIGSYS trap");
 384                 exit(1);
 385         }
 386 #endif
 387         exit(0);
 388 }
 389
 390 #ifdef SIGSYS
 391 /*
 392  * pll_trap - trap processor for undefined syscalls
 393  */
 394 void
 395 pll_trap(
 396         int arg
 397         )
 398 {
 399         pll_control--;
 400         siglongjmp(env, 1);
 401 }
 402 #endif
 403
 404 /*
 405  * Print a value a la the %b format of the kernel's printf
 406  */
 407 const char *
 408 sprintb(
 409         u_int           v,
 410         const char *    bits
 411         )
 412 {
 413         char *cp;
 414         char *cplim;
 415         int i;
 416         int any;
 417         char c;
 418         static char buf[132];
 419
 420         if (bits != NULL && *bits == 8)
 421                 snprintf(buf, sizeof(buf), "0%o", v);
 422         else
 423                 snprintf(buf, sizeof(buf), "0x%x", v);
 424         cp = buf + strlen(buf);
 425         cplim = buf + sizeof(buf);
 426         if (bits != NULL) {
 427                 bits++;
 428                 *cp++ = ' ';
 429                 *cp++ = '(';
 430                 any = FALSE;
 431                 while ((i = *bits++) != 0) {
 432                         if (v & (1 << (i - 1))) {
 433                                 if (any) {
 434                                         *cp++ = ',';
 435                                         if (cp >= cplim)
 436                                                 goto overrun;
 437                                 }
 438                                 any = TRUE;
 439                                 for (; (c = *bits) > 32; bits++) {
 440                                         *cp++ = c;
 441                                         if (cp >= cplim)
 442                                                 goto overrun;
 443                                 }
 444                         } else {
 445                                 for (; *bits > 32; bits++)
 446                                         continue;
 447                         }
 448                 }
 449                 *cp++ = ')';
 450                 if (cp >= cplim)
 451                         goto overrun;
 452         }
 453         *cp = '\0';
 454         return buf;
 455
 456     overrun:
 457         return "sprintb buffer too small";
 458 }
 459
 460 const char * const timex_states[] = {
 461         "OK", "INS", "DEL", "OOP", "WAIT", "ERROR"
 462 };
 463
 464 const char *
 465 timex_state(
 466         int s
 467         )
 468 {
 469         static char buf[32];
 470
 471         if ((size_t)s < COUNTOF(timex_states))
 472                 return timex_states[s];
 473         snprintf(buf, sizeof(buf), "TIME-#%d", s);
 474         return buf;
 475 }