contrib/ntp/ntpd/refclock_shm.c

   1 /*
   2  * refclock_shm - clock driver for utc via shared memory
   3  * - under construction -
   4  * To add new modes: Extend or union the shmTime-struct. Do not
   5  * extend/shrink size, because otherwise existing implementations
   6  * will specify wrong size of shared memory-segment
   7  * PB 18.3.97
   8  */
   9
  10 #ifdef HAVE_CONFIG_H
  11 # include <config.h>
  12 #endif
  13
  14 #include "ntp_types.h"
  15
  16 #if defined(REFCLOCK) && defined(CLOCK_SHM)
  17
  18 #include "ntpd.h"
  19 #undef fileno
  20 #include "ntp_io.h"
  21 #undef fileno
  22 #include "ntp_refclock.h"
  23 #undef fileno
  24 #include "timespecops.h"
  25 #undef fileno
  26 #include "ntp_stdlib.h"
  27 #include "ntp_assert.h"
  28
  29 #undef fileno
  30 #include <ctype.h>
  31 #undef fileno
  32
  33 #ifndef SYS_WINNT
  34 # include <sys/ipc.h>
  35 # include <sys/shm.h>
  36 # include <assert.h>
  37 # include <unistd.h>
  38 # include <stdio.h>
  39 #endif
  40
  41 #ifdef HAVE_STDATOMIC_H
  42 # include <stdatomic.h>
  43 #endif /* HAVE_STDATOMIC_H */
  44
  45 /*
  46  * This driver supports a reference clock attached thru shared memory
  47  */
  48
  49 /*
  50  * SHM interface definitions
  51  */
  52 #define PRECISION       (-1)    /* precision assumed (0.5 s) */
  53 #define REFID           "SHM"   /* reference ID */
  54 #define DESCRIPTION     "SHM/Shared memory interface"
  55
  56 #define NSAMPLES        3       /* stages of median filter */
  57
  58 /*
  59  * Mode flags
  60  */
  61 #define SHM_MODE_PRIVATE 0x0001
  62
  63 /*
  64  * Function prototypes
  65  */
  66 static  int     shm_start       (int unit, struct peer *peer);
  67 static  void    shm_shutdown    (int unit, struct peer *peer);
  68 static  void    shm_poll        (int unit, struct peer *peer);
  69 static  void    shm_timer       (int unit, struct peer *peer);
  70 static  void    shm_clockstats  (int unit, struct peer *peer);
  71 static  void    shm_control     (int unit, const struct refclockstat * in_st,
  72                                  struct refclockstat * out_st, struct peer *peer);
  73
  74 /*
  75  * Transfer vector
  76  */
  77 struct  refclock refclock_shm = {
  78         shm_start,              /* start up driver */
  79         shm_shutdown,           /* shut down driver */
  80         shm_poll,               /* transmit poll message */
  81         shm_control,            /* control settings */
  82         noentry,                /* not used: init */
  83         noentry,                /* not used: buginfo */
  84         shm_timer,              /* once per second */
  85 };
  86
  87 struct shmTime {
  88         int    mode; /* 0 - if valid is set:
  89                       *       use values,
  90                       *       clear valid
  91                       * 1 - if valid is set:
  92                       *       if count before and after read of values is equal,
  93                       *         use values
  94                       *       clear valid
  95                       */
  96         volatile int    count;
  97         time_t          clockTimeStampSec;
  98         int             clockTimeStampUSec;
  99         time_t          receiveTimeStampSec;
 100         int             receiveTimeStampUSec;
 101         int             leap;
 102         int             precision;
 103         int             nsamples;
 104         volatile int    valid;
 105         unsigned        clockTimeStampNSec;     /* Unsigned ns timestamps */
 106         unsigned        receiveTimeStampNSec;   /* Unsigned ns timestamps */
 107         int             dummy[8];
 108 };
 109
 110 struct shmunit {
 111         struct shmTime *shm;    /* pointer to shared memory segment */
 112         int forall;             /* access for all UIDs? */
 113
 114         /* debugging/monitoring counters - reset when printed */
 115         int ticks;              /* number of attempts to read data*/
 116         int good;               /* number of valid samples */
 117         int notready;           /* number of peeks without data ready */
 118         int bad;                /* number of invalid samples */
 119         int clash;              /* number of access clashes while reading */
 120
 121         time_t max_delta;       /* difference limit */
 122         time_t max_delay;       /* age/stale limit */
 123 };
 124
 125
 126 static struct shmTime*
 127 getShmTime(
 128         int unit,
 129         int/*BOOL*/ forall
 130         )
 131 {
 132         struct shmTime *p = NULL;
 133
 134 #ifndef SYS_WINNT
 135
 136         int shmid;
 137
 138         /* 0x4e545030 is NTP0.
 139          * Big units will give non-ascii but that's OK
 140          * as long as everybody does it the same way.
 141          */
 142         shmid=shmget(0x4e545030 + unit, sizeof (struct shmTime),
 143                       IPC_CREAT | (forall ? 0666 : 0600));
 144         if (shmid == -1) { /* error */
 145                 msyslog(LOG_ERR, "SHM shmget (unit %d): %m", unit);
 146                 return NULL;
 147         }
 148         p = (struct shmTime *)shmat (shmid, 0, 0);
 149         if (p == (struct shmTime *)-1) { /* error */
 150                 msyslog(LOG_ERR, "SHM shmat (unit %d): %m", unit);
 151                 return NULL;
 152         }
 153
 154         return p;
 155 #else
 156
 157         static const char * nspref[2] = { "Local", "Global" };
 158         char buf[20];
 159         LPSECURITY_ATTRIBUTES psec = 0;
 160         HANDLE shmid = 0;
 161         SECURITY_DESCRIPTOR sd;
 162         SECURITY_ATTRIBUTES sa;
 163         unsigned int numch;
 164
 165         numch = snprintf(buf, sizeof(buf), "%s\\NTP%d",
 166                          nspref[forall != 0], (unit & 0xFF));
 167         if (numch >= sizeof(buf)) {
 168                 msyslog(LOG_ERR, "SHM name too long (unit %d)", unit);
 169                 return NULL;
 170         }
 171         if (forall) { /* world access */
 172                 if (!InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION)) {
 173                         msyslog(LOG_ERR,"SHM InitializeSecurityDescriptor (unit %d): %m", unit);
 174                         return NULL;
 175                 }
 176                 if (!SetSecurityDescriptorDacl(&sd, TRUE, NULL, FALSE)) {
 177                         msyslog(LOG_ERR, "SHM SetSecurityDescriptorDacl (unit %d): %m", unit);
 178                         return NULL;
 179                 }
 180                 sa.nLength = sizeof(SECURITY_ATTRIBUTES);
 181                 sa.lpSecurityDescriptor = &sd;
 182                 sa.bInheritHandle = FALSE;
 183                 psec = &sa;
 184         }
 185         shmid = CreateFileMapping ((HANDLE)0xffffffff, psec, PAGE_READWRITE,
 186                                    0, sizeof (struct shmTime), buf);
 187         if (shmid == NULL) { /*error*/
 188                 char buf[1000];
 189                 FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM,
 190                                0, GetLastError (), 0, buf, sizeof (buf), 0);
 191                 msyslog(LOG_ERR, "SHM CreateFileMapping (unit %d): %s", unit, buf);
 192                 return NULL;
 193         }
 194         p = (struct shmTime *)MapViewOfFile(shmid, FILE_MAP_WRITE, 0, 0,
 195                                             sizeof (struct shmTime));
 196         if (p == NULL) { /*error*/
 197                 char buf[1000];
 198                 FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM,
 199                                0, GetLastError (), 0, buf, sizeof (buf), 0);
 200                 msyslog(LOG_ERR,"SHM MapViewOfFile (unit %d): %s", unit, buf);
 201                 return NULL;
 202         }
 203
 204         return p;
 205 #endif
 206
 207         /* NOTREACHED */
 208         ENSURE(!"getShmTime(): Not reached.");
 209 }
 210
 211
 212 /*
 213  * shm_start - attach to shared memory
 214  */
 215 static int
 216 shm_start(
 217         int unit,
 218         struct peer *peer
 219         )
 220 {
 221         struct refclockproc * const pp = peer->procptr;
 222         struct shmunit *      const up = emalloc_zero(sizeof(*up));
 223
 224         pp->io.clock_recv = noentry;
 225         pp->io.srcclock = peer;
 226         pp->io.datalen = 0;
 227         pp->io.fd = -1;
 228
 229         up->forall = (unit >= 2) && !(peer->ttl & SHM_MODE_PRIVATE);
 230
 231         up->shm = getShmTime(unit, up->forall);
 232
 233         /*
 234          * Initialize miscellaneous peer variables
 235          */
 236         memcpy((char *)&pp->refid, REFID, 4);
 237         if (up->shm != 0) {
 238                 pp->unitptr = up;
 239                 up->shm->precision = PRECISION;
 240                 peer->precision = up->shm->precision;
 241                 up->shm->valid = 0;
 242                 up->shm->nsamples = NSAMPLES;
 243                 pp->clockdesc = DESCRIPTION;
 244                 /* items to be changed later in 'shm_control()': */
 245                 up->max_delay = 5;
 246                 up->max_delta = 4*3600;
 247                 return 1;
 248         } else {
 249                 free(up);
 250                 pp->unitptr = NULL;
 251                 return 0;
 252         }
 253 }
 254
 255
 256 /*
 257  * shm_control - configure flag1/time2 params
 258  *
 259  * These are not yet available during 'shm_start', so we have to do any
 260  * pre-computations we want to avoid during regular poll/timer callbacks
 261  * in this callback.
 262  */
 263 static void
 264 shm_control(
 265         int                         unit,
 266         const struct refclockstat * in_st,
 267         struct refclockstat       * out_st,
 268         struct peer               * peer
 269         )
 270 {
 271         struct refclockproc * const pp = peer->procptr;
 272         struct shmunit *      const up = pp->unitptr;
 273
 274         UNUSED_ARG(unit);
 275         UNUSED_ARG(in_st);
 276         UNUSED_ARG(out_st);
 277         if (NULL == up)
 278                 return;
 279         if (pp->sloppyclockflag & CLK_FLAG1)
 280                 up->max_delta = 0;
 281         else if (pp->fudgetime2 < 1. || pp->fudgetime2 > 86400.)
 282                 up->max_delta = 4*3600;
 283         else
 284                 up->max_delta = (time_t)floor(pp->fudgetime2 + 0.5);
 285 }
 286
 287
 288 /*
 289  * shm_shutdown - shut down the clock
 290  */
 291 static void
 292 shm_shutdown(
 293         int unit,
 294         struct peer *peer
 295         )
 296 {
 297         struct refclockproc * const pp = peer->procptr;
 298         struct shmunit *      const up = pp->unitptr;
 299
 300         UNUSED_ARG(unit);
 301         if (NULL == up)
 302                 return;
 303 #ifndef SYS_WINNT
 304
 305         /* HMS: shmdt() wants char* or const void * */
 306         (void)shmdt((char *)up->shm);
 307
 308 #else
 309
 310         UnmapViewOfFile(up->shm);
 311
 312 #endif
 313         free(up);
 314 }
 315
 316
 317 /*
 318  * shm_poll - called by the transmit procedure
 319  */
 320 static void
 321 shm_poll(
 322         int unit,
 323         struct peer *peer
 324         )
 325 {
 326         struct refclockproc * const pp = peer->procptr;
 327         struct shmunit *      const up = pp->unitptr;
 328         int major_error;
 329
 330         pp->polls++;
 331
 332         /* get dominant reason if we have no samples at all */
 333         major_error = max(up->notready, up->bad);
 334         major_error = max(major_error, up->clash);
 335
 336         /*
 337          * Process median filter samples. If none received, see what
 338          * happened, tell the core and keep going.
 339          */
 340         if (pp->coderecv != pp->codeproc) {
 341                 /* have some samples, everything OK */
 342                 pp->lastref = pp->lastrec;
 343                 refclock_report(peer, CEVNT_NOMINAL);
 344                 refclock_receive(peer);
 345         } else if (NULL == up->shm) { /* is this possible at all? */
 346                 /* we're out of business without SHM access */
 347                 refclock_report(peer, CEVNT_FAULT);
 348         } else if (major_error == up->clash) {
 349                 /* too many collisions is like a bad signal */
 350                 refclock_report(peer, CEVNT_PROP);
 351         } else if (major_error == up->bad) {
 352                 /* too much stale/bad/garbled data */
 353                 refclock_report(peer, CEVNT_BADREPLY);
 354         } else {
 355                 /* in any other case assume it's just a timeout */
 356                 refclock_report(peer, CEVNT_TIMEOUT);
 357         }
 358         /* shm_clockstats() clears the tallies, so it must be last... */
 359         shm_clockstats(unit, peer);
 360 }
 361
 362
 363 enum segstat_t {
 364     OK, NO_SEGMENT, NOT_READY, BAD_MODE, CLASH
 365 };
 366
 367 struct shm_stat_t {
 368     int status;
 369     int mode;
 370     struct timespec tvc, tvr, tvt;
 371     int precision;
 372     int leap;
 373 };
 374
 375 static inline void memory_barrier(void)
 376 {
 377 #ifdef HAVE_ATOMIC_THREAD_FENCE
 378     atomic_thread_fence(memory_order_seq_cst);
 379 #endif /* HAVE_ATOMIC_THREAD_FENCE */
 380 }
 381
 382 static enum segstat_t shm_query(volatile struct shmTime *shm_in, struct shm_stat_t *shm_stat)
 383 /* try to grab a sample from the specified SHM segment */
 384 {
 385     struct shmTime shmcopy;
 386     volatile struct shmTime *shm = shm_in;
 387     volatile int cnt;
 388
 389     unsigned int cns_new, rns_new;
 390
 391     /*
 392      * This is the main routine. It snatches the time from the shm
 393      * board and tacks on a local timestamp.
 394      */
 395     if (shm == NULL) {
 396         shm_stat->status = NO_SEGMENT;
 397         return NO_SEGMENT;
 398     }
 399
 400     /*@-type@*//* splint is confused about struct timespec */
 401     shm_stat->tvc.tv_sec = shm_stat->tvc.tv_nsec = 0;
 402     {
 403         time_t now;
 404
 405         time(&now);
 406         shm_stat->tvc.tv_sec = now;
 407     }
 408
 409     /* relying on word access to be atomic here */
 410     if (shm->valid == 0) {
 411         shm_stat->status = NOT_READY;
 412         return NOT_READY;
 413     }
 414
 415     cnt = shm->count;
 416
 417     /*
 418      * This is proof against concurrency issues if either
 419      * (a) the memory_barrier() call works on this host, or
 420      * (b) memset compiles to an uninterruptible single-instruction bitblt.
 421      */
 422     memory_barrier();
 423     memcpy(&shmcopy, (void*)(uintptr_t)shm, sizeof(struct shmTime));
 424     shm->valid = 0;
 425     memory_barrier();
 426
 427     /*
 428      * Clash detection in case neither (a) nor (b) was true.
 429      * Not supported in mode 0, and word access to the count field
 430      * must be atomic for this to work.
 431      */
 432     if (shmcopy.mode > 0 && cnt != shm->count) {
 433         shm_stat->status = CLASH;
 434         return shm_stat->status;
 435     }
 436
 437     shm_stat->status = OK;
 438     shm_stat->mode = shmcopy.mode;
 439
 440     switch (shmcopy.mode) {
 441     case 0:
 442         shm_stat->tvr.tv_sec    = shmcopy.receiveTimeStampSec;
 443         shm_stat->tvr.tv_nsec   = shmcopy.receiveTimeStampUSec * 1000;
 444         rns_new         = shmcopy.receiveTimeStampNSec;
 445         shm_stat->tvt.tv_sec    = shmcopy.clockTimeStampSec;
 446         shm_stat->tvt.tv_nsec   = shmcopy.clockTimeStampUSec * 1000;
 447         cns_new         = shmcopy.clockTimeStampNSec;
 448
 449         /* Since the following comparisons are between unsigned
 450         ** variables they are always well defined, and any
 451         ** (signed) underflow will turn into very large unsigned
 452         ** values, well above the 1000 cutoff.
 453         **
 454         ** Note: The usecs *must* be a *truncated*
 455         ** representation of the nsecs. This code will fail for
 456         ** *rounded* usecs, and the logic to deal with
 457         ** wrap-arounds in the presence of rounded values is
 458         ** much more convoluted.
 459         */
 460         if (   ((cns_new - (unsigned)shm_stat->tvt.tv_nsec) < 1000)
 461                && ((rns_new - (unsigned)shm_stat->tvr.tv_nsec) < 1000)) {
 462             shm_stat->tvt.tv_nsec = cns_new;
 463             shm_stat->tvr.tv_nsec = rns_new;
 464         }
 465         /* At this point shm_stat->tvr and shm_stat->tvt contain valid ns-level
 466         ** timestamps, possibly generated by extending the old
 467         ** us-level timestamps
 468         */
 469         break;
 470
 471     case 1:
 472
 473         shm_stat->tvr.tv_sec    = shmcopy.receiveTimeStampSec;
 474         shm_stat->tvr.tv_nsec   = shmcopy.receiveTimeStampUSec * 1000;
 475         rns_new         = shmcopy.receiveTimeStampNSec;
 476         shm_stat->tvt.tv_sec    = shmcopy.clockTimeStampSec;
 477         shm_stat->tvt.tv_nsec   = shmcopy.clockTimeStampUSec * 1000;
 478         cns_new         = shmcopy.clockTimeStampNSec;
 479
 480         /* See the case above for an explanation of the
 481         ** following test.
 482         */
 483         if (   ((cns_new - (unsigned)shm_stat->tvt.tv_nsec) < 1000)
 484                && ((rns_new - (unsigned)shm_stat->tvr.tv_nsec) < 1000)) {
 485             shm_stat->tvt.tv_nsec = cns_new;
 486             shm_stat->tvr.tv_nsec = rns_new;
 487         }
 488         /* At this point shm_stat->tvr and shm_stat->tvt contains valid ns-level
 489         ** timestamps, possibly generated by extending the old
 490         ** us-level timestamps
 491         */
 492         break;
 493
 494     default:
 495         shm_stat->status = BAD_MODE;
 496         break;
 497     }
 498     /*@-type@*/
 499
 500     /*
 501      * leap field is not a leap offset but a leap notification code.
 502      * The values are magic numbers used by NTP and set by GPSD, if at all, in
 503      * the subframe code.
 504      */
 505     shm_stat->leap = shmcopy.leap;
 506     shm_stat->precision = shmcopy.precision;
 507
 508     return shm_stat->status;
 509 }
 510
 511 /*
 512  * shm_timer - called once every second.
 513  *
 514  * This tries to grab a sample from the SHM segment, filtering bad ones
 515  */
 516 static void
 517 shm_timer(
 518         int unit,
 519         struct peer *peer
 520         )
 521 {
 522         struct refclockproc * const pp = peer->procptr;
 523         struct shmunit *      const up = pp->unitptr;
 524
 525         volatile struct shmTime *shm;
 526
 527         l_fp tsrcv;
 528         l_fp tsref;
 529         int c;
 530
 531         /* for formatting 'a_lastcode': */
 532         struct calendar cd;
 533         time_t tt;
 534         vint64 ts;
 535
 536         enum segstat_t status;
 537         struct shm_stat_t shm_stat;
 538
 539         up->ticks++;
 540         if ((shm = up->shm) == NULL) {
 541                 /* try to map again - this may succeed if meanwhile some-
 542                 body has ipcrm'ed the old (unaccessible) shared mem segment */
 543                 shm = up->shm = getShmTime(unit, up->forall);
 544                 if (shm == NULL) {
 545                         DPRINTF(1, ("%s: no SHM segment\n",
 546                                     refnumtoa(&peer->srcadr)));
 547                         return;
 548                 }
 549         }
 550
 551         /* query the segment, atomically */
 552         status = shm_query(shm, &shm_stat);
 553
 554         switch (status) {
 555         case OK:
 556             DPRINTF(2, ("%s: SHM type %d sample\n",
 557                         refnumtoa(&peer->srcadr), shm_stat.mode));
 558             break;
 559         case NO_SEGMENT:
 560             /* should never happen, but is harmless */
 561             return;
 562         case NOT_READY:
 563             DPRINTF(1, ("%s: SHM not ready\n",refnumtoa(&peer->srcadr)));
 564             up->notready++;
 565             return;
 566         case BAD_MODE:
 567             DPRINTF(1, ("%s: SHM type blooper, mode=%d\n",
 568                         refnumtoa(&peer->srcadr), shm->mode));
 569             up->bad++;
 570             msyslog (LOG_ERR, "SHM: bad mode found in shared memory: %d",
 571                      shm->mode);
 572             return;
 573         case CLASH:
 574             DPRINTF(1, ("%s: type 1 access clash\n",
 575                         refnumtoa(&peer->srcadr)));
 576             msyslog (LOG_NOTICE, "SHM: access clash in shared memory");
 577             up->clash++;
 578             return;
 579         default:
 580             DPRINTF(1, ("%s: internal error, unknown SHM fetch status\n",
 581                         refnumtoa(&peer->srcadr)));
 582             msyslog (LOG_NOTICE, "internal error, unknown SHM fetch status");
 583             up->bad++;
 584             return;
 585         }
 586
 587
 588         /* format the last time code in human-readable form into
 589          * 'pp->a_lastcode'. Someone claimed: "NetBSD has incompatible
 590          * tv_sec". I can't find a base for this claim, but we can work
 591          * around that potential problem. BTW, simply casting a pointer
 592          * is a receipe for disaster on some architectures.
 593          */
 594         tt = (time_t)shm_stat.tvt.tv_sec;
 595         ts = time_to_vint64(&tt);
 596         ntpcal_time_to_date(&cd, &ts);
 597
 598         /* add ntpq -c cv timecode in ISO 8601 format */
 599         c = snprintf(pp->a_lastcode, sizeof(pp->a_lastcode),
 600                      "%04u-%02u-%02uT%02u:%02u:%02u.%09ldZ",
 601                      cd.year, cd.month, cd.monthday,
 602                      cd.hour, cd.minute, cd.second,
 603                      (long)shm_stat.tvt.tv_nsec);
 604         pp->lencode = (c > 0 && (size_t)c < sizeof(pp->a_lastcode)) ? c : 0;
 605
 606         /* check 1: age control of local time stamp */
 607         tt = shm_stat.tvc.tv_sec - shm_stat.tvr.tv_sec;
 608         if (tt < 0 || tt > up->max_delay) {
 609                 DPRINTF(1, ("%s:SHM stale/bad receive time, delay=%llds\n",
 610                             refnumtoa(&peer->srcadr), (long long)tt));
 611                 up->bad++;
 612                 msyslog (LOG_ERR, "SHM: stale/bad receive time, delay=%llds",
 613                          (long long)tt);
 614                 return;
 615         }
 616
 617         /* check 2: delta check */
 618         tt = shm_stat.tvr.tv_sec - shm_stat.tvt.tv_sec - (shm_stat.tvr.tv_nsec < shm_stat.tvt.tv_nsec);
 619         if (tt < 0)
 620                 tt = -tt;
 621         if (up->max_delta > 0 && tt > up->max_delta) {
 622                 DPRINTF(1, ("%s: SHM diff limit exceeded, delta=%llds\n",
 623                             refnumtoa(&peer->srcadr), (long long)tt));
 624                 up->bad++;
 625                 msyslog (LOG_ERR, "SHM: difference limit exceeded, delta=%llds\n",
 626                          (long long)tt);
 627                 return;
 628         }
 629
 630         /* if we really made it to this point... we're winners! */
 631         DPRINTF(2, ("%s: SHM feeding data\n",
 632                     refnumtoa(&peer->srcadr)));
 633         tsrcv = tspec_stamp_to_lfp(shm_stat.tvr);
 634         tsref = tspec_stamp_to_lfp(shm_stat.tvt);
 635         pp->leap = shm_stat.leap;
 636         peer->precision = shm_stat.precision;
 637         refclock_process_offset(pp, tsref, tsrcv, pp->fudgetime1);
 638         up->good++;
 639 }
 640
 641 /*
 642  * shm_clockstats - dump and reset counters
 643  */
 644 static void shm_clockstats(
 645         int unit,
 646         struct peer *peer
 647         )
 648 {
 649         struct refclockproc * const pp = peer->procptr;
 650         struct shmunit *      const up = pp->unitptr;
 651
 652         UNUSED_ARG(unit);
 653         if (pp->sloppyclockflag & CLK_FLAG4) {
 654                 mprintf_clock_stats(
 655                         &peer->srcadr, "%3d %3d %3d %3d %3d",
 656                         up->ticks, up->good, up->notready,
 657                         up->bad, up->clash);
 658         }
 659         up->ticks = up->good = up->notready = up->bad = up->clash = 0;
 660 }
 661
 662 #else
 663 NONEMPTY_TRANSLATION_UNIT
 664 #endif /* REFCLOCK */