1 /* $NetBSD: kern_ntptime.c,v 1.39 2006/10/13 16:53:36 dogcow Exp $ */ 2 #include <sys/types.h> /* XXX to get __HAVE_TIMECOUNTER, remove 3 after all ports are converted. */ 4 #ifdef __HAVE_TIMECOUNTER 5 6 /*- 7 *********************************************************************** 8 * * 9 * Copyright (c) David L. Mills 1993-2001 * 10 * * 11 * Permission to use, copy, modify, and distribute this software and * 12 * its documentation for any purpose and without fee is hereby * 13 * granted, provided that the above copyright notice appears in all * 14 * copies and that both the copyright notice and this permission * 15 * notice appear in supporting documentation, and that the name * 16 * University of Delaware not be used in advertising or publicity * 17 * pertaining to distribution of the software without specific, * 18 * written prior permission. The University of Delaware makes no * 19 * representations about the suitability this software for any * 20 * purpose. It is provided "as is" without express or implied * 21 * warranty. * 22 * * 23 **********************************************************************/ 24 25 /* 26 * Adapted from the original sources for FreeBSD and timecounters by: 27 * Poul-Henning Kamp <phk@FreeBSD.org>. 28 * 29 * The 32bit version of the "LP" macros seems a bit past its "sell by" 30 * date so I have retained only the 64bit version and included it directly 31 * in this file. 32 * 33 * Only minor changes done to interface with the timecounters over in 34 * sys/kern/kern_clock.c. Some of the comments below may be (even more) 35 * confusing and/or plain wrong in that context. 36 */ 37 38 #include <sys/cdefs.h> 39 /* __FBSDID("$FreeBSD: src/sys/kern/kern_ntptime.c,v 1.59 2005/05/28 14:34:41 rwatson Exp $"); */ 40 __KERNEL_RCSID(0, "$NetBSD: kern_ntptime.c,v 1.39 2006/10/13 16:53:36 dogcow Exp $"); 41 42 #include "opt_ntp.h" 43 #include "opt_compat_netbsd.h" 44 45 #include <sys/param.h> 46 #include <sys/resourcevar.h> 47 #include <sys/systm.h> 48 #include <sys/kernel.h> 49 #include <sys/proc.h> 50 #include <sys/sysctl.h> 51 #include <sys/timex.h> 52 #ifdef COMPAT_30 53 #include <compat/sys/timex.h> 54 #endif 55 #include <sys/vnode.h> 56 #include <sys/kauth.h> 57 58 #include <sys/mount.h> 59 #include <sys/sa.h> 60 #include <sys/syscallargs.h> 61 62 #include <machine/cpu.h> 63 64 /* 65 * Single-precision macros for 64-bit machines 66 */ 67 typedef int64_t l_fp; 68 #define L_ADD(v, u) ((v) += (u)) 69 #define L_SUB(v, u) ((v) -= (u)) 70 #define L_ADDHI(v, a) ((v) += (int64_t)(a) << 32) 71 #define L_NEG(v) ((v) = -(v)) 72 #define L_RSHIFT(v, n) \ 73 do { \ 74 if ((v) < 0) \ 75 (v) = -(-(v) >> (n)); \ 76 else \ 77 (v) = (v) >> (n); \ 78 } while (0) 79 #define L_MPY(v, a) ((v) *= (a)) 80 #define L_CLR(v) ((v) = 0) 81 #define L_ISNEG(v) ((v) < 0) 82 #define L_LINT(v, a) ((v) = (int64_t)(a) << 32) 83 #define L_GINT(v) ((v) < 0 ? -(-(v) >> 32) : (v) >> 32) 84 85 #ifdef NTP 86 /* 87 * Generic NTP kernel interface 88 * 89 * These routines constitute the Network Time Protocol (NTP) interfaces 90 * for user and daemon application programs. The ntp_gettime() routine 91 * provides the time, maximum error (synch distance) and estimated error 92 * (dispersion) to client user application programs. The ntp_adjtime() 93 * routine is used by the NTP daemon to adjust the system clock to an 94 * externally derived time. The time offset and related variables set by 95 * this routine are used by other routines in this module to adjust the 96 * phase and frequency of the clock discipline loop which controls the 97 * system clock. 98 * 99 * When the kernel time is reckoned directly in nanoseconds (NTP_NANO 100 * defined), the time at each tick interrupt is derived directly from 101 * the kernel time variable. When the kernel time is reckoned in 102 * microseconds, (NTP_NANO undefined), the time is derived from the 103 * kernel time variable together with a variable representing the 104 * leftover nanoseconds at the last tick interrupt. In either case, the 105 * current nanosecond time is reckoned from these values plus an 106 * interpolated value derived by the clock routines in another 107 * architecture-specific module. The interpolation can use either a 108 * dedicated counter or a processor cycle counter (PCC) implemented in 109 * some architectures. 110 * 111 * Note that all routines must run at priority splclock or higher. 112 */ 113 /* 114 * Phase/frequency-lock loop (PLL/FLL) definitions 115 * 116 * The nanosecond clock discipline uses two variable types, time 117 * variables and frequency variables. Both types are represented as 64- 118 * bit fixed-point quantities with the decimal point between two 32-bit 119 * halves. On a 32-bit machine, each half is represented as a single 120 * word and mathematical operations are done using multiple-precision 121 * arithmetic. On a 64-bit machine, ordinary computer arithmetic is 122 * used. 123 * 124 * A time variable is a signed 64-bit fixed-point number in ns and 125 * fraction. It represents the remaining time offset to be amortized 126 * over succeeding tick interrupts. The maximum time offset is about 127 * 0.5 s and the resolution is about 2.3e-10 ns. 128 * 129 * 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3 130 * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 131 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 132 * |s s s| ns | 133 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 134 * | fraction | 135 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 136 * 137 * A frequency variable is a signed 64-bit fixed-point number in ns/s 138 * and fraction. It represents the ns and fraction to be added to the 139 * kernel time variable at each second. The maximum frequency offset is 140 * about +-500000 ns/s and the resolution is about 2.3e-10 ns/s. 141 * 142 * 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3 143 * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 144 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 145 * |s s s s s s s s s s s s s| ns/s | 146 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 147 * | fraction | 148 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 149 */ 150 /* 151 * The following variables establish the state of the PLL/FLL and the 152 * residual time and frequency offset of the local clock. 153 */ 154 #define SHIFT_PLL 4 /* PLL loop gain (shift) */ 155 #define SHIFT_FLL 2 /* FLL loop gain (shift) */ 156 157 static int time_state = TIME_OK; /* clock state */ 158 static int time_status = STA_UNSYNC; /* clock status bits */ 159 static long time_tai; /* TAI offset (s) */ 160 static long time_monitor; /* last time offset scaled (ns) */ 161 static long time_constant; /* poll interval (shift) (s) */ 162 static long time_precision = 1; /* clock precision (ns) */ 163 static long time_maxerror = MAXPHASE / 1000; /* maximum error (us) */ 164 static long time_esterror = MAXPHASE / 1000; /* estimated error (us) */ 165 static long time_reftime; /* time at last adjustment (s) */ 166 static l_fp time_offset; /* time offset (ns) */ 167 static l_fp time_freq; /* frequency offset (ns/s) */ 168 #endif /* NTP */ 169 170 static l_fp time_adj; /* tick adjust (ns/s) */ 171 int64_t time_adjtime; /* correction from adjtime(2) (usec) */ 172 173 extern int time_adjusted; /* ntp might have changed the system time */ 174 175 #ifdef NTP 176 #ifdef PPS_SYNC 177 /* 178 * The following variables are used when a pulse-per-second (PPS) signal 179 * is available and connected via a modem control lead. They establish 180 * the engineering parameters of the clock discipline loop when 181 * controlled by the PPS signal. 182 */ 183 #define PPS_FAVG 2 /* min freq avg interval (s) (shift) */ 184 #define PPS_FAVGDEF 8 /* default freq avg int (s) (shift) */ 185 #define PPS_FAVGMAX 15 /* max freq avg interval (s) (shift) */ 186 #define PPS_PAVG 4 /* phase avg interval (s) (shift) */ 187 #define PPS_VALID 120 /* PPS signal watchdog max (s) */ 188 #define PPS_MAXWANDER 100000 /* max PPS wander (ns/s) */ 189 #define PPS_POPCORN 2 /* popcorn spike threshold (shift) */ 190 191 static struct timespec pps_tf[3]; /* phase median filter */ 192 static l_fp pps_freq; /* scaled frequency offset (ns/s) */ 193 static long pps_fcount; /* frequency accumulator */ 194 static long pps_jitter; /* nominal jitter (ns) */ 195 static long pps_stabil; /* nominal stability (scaled ns/s) */ 196 static long pps_lastsec; /* time at last calibration (s) */ 197 static int pps_valid; /* signal watchdog counter */ 198 static int pps_shift = PPS_FAVG; /* interval duration (s) (shift) */ 199 static int pps_shiftmax = PPS_FAVGDEF; /* max interval duration (s) (shift) */ 200 static int pps_intcnt; /* wander counter */ 201 202 /* 203 * PPS signal quality monitors 204 */ 205 static long pps_calcnt; /* calibration intervals */ 206 static long pps_jitcnt; /* jitter limit exceeded */ 207 static long pps_stbcnt; /* stability limit exceeded */ 208 static long pps_errcnt; /* calibration errors */ 209 #endif /* PPS_SYNC */ 210 /* 211 * End of phase/frequency-lock loop (PLL/FLL) definitions 212 */ 213 214 static void hardupdate(long offset); 215 216 /* 217 * ntp_gettime() - NTP user application interface 218 */ 219 void 220 ntp_gettime(ntv) 221 struct ntptimeval *ntv; 222 { 223 nanotime(&ntv->time); 224 ntv->maxerror = time_maxerror; 225 ntv->esterror = time_esterror; 226 ntv->tai = time_tai; 227 ntv->time_state = time_state; 228 } 229 230 /* ARGSUSED */ 231 /* 232 * ntp_adjtime() - NTP daemon application interface 233 */ 234 int 235 sys_ntp_adjtime(l, v, retval) 236 struct lwp *l; 237 void *v; 238 register_t *retval; 239 { 240 struct sys_ntp_adjtime_args /* { 241 syscallarg(struct timex *) tp; 242 } */ *uap = v; 243 struct timex ntv; 244 int error = 0; 245 246 error = copyin((caddr_t)SCARG(uap, tp), (caddr_t)&ntv, sizeof(ntv)); 247 if (error != 0) 248 return (error); 249 250 if (ntv.modes != 0 && (error = kauth_authorize_system(l->l_cred, 251 KAUTH_SYSTEM_TIME, KAUTH_REQ_SYSTEM_TIME_NTPADJTIME, NULL, 252 NULL, NULL)) != 0) 253 return (error); 254 255 ntp_adjtime1(&ntv); 256 257 error = copyout((caddr_t)&ntv, (caddr_t)SCARG(uap, tp), sizeof(ntv)); 258 if (!error) 259 *retval = ntp_timestatus(); 260 261 return error; 262 } 263 264 void 265 ntp_adjtime1(ntv) 266 struct timex *ntv; 267 { 268 long freq; 269 int modes; 270 int s; 271 272 /* 273 * Update selected clock variables - only the superuser can 274 * change anything. Note that there is no error checking here on 275 * the assumption the superuser should know what it is doing. 276 * Note that either the time constant or TAI offset are loaded 277 * from the ntv.constant member, depending on the mode bits. If 278 * the STA_PLL bit in the status word is cleared, the state and 279 * status words are reset to the initial values at boot. 280 */ 281 modes = ntv->modes; 282 if (modes != 0) 283 /* We need to save the system time during shutdown */ 284 time_adjusted |= 2; 285 s = splclock(); 286 if (modes & MOD_MAXERROR) 287 time_maxerror = ntv->maxerror; 288 if (modes & MOD_ESTERROR) 289 time_esterror = ntv->esterror; 290 if (modes & MOD_STATUS) { 291 if (time_status & STA_PLL && !(ntv->status & STA_PLL)) { 292 time_state = TIME_OK; 293 time_status = STA_UNSYNC; 294 #ifdef PPS_SYNC 295 pps_shift = PPS_FAVG; 296 #endif /* PPS_SYNC */ 297 } 298 time_status &= STA_RONLY; 299 time_status |= ntv->status & ~STA_RONLY; 300 } 301 if (modes & MOD_TIMECONST) { 302 if (ntv->constant < 0) 303 time_constant = 0; 304 else if (ntv->constant > MAXTC) 305 time_constant = MAXTC; 306 else 307 time_constant = ntv->constant; 308 } 309 if (modes & MOD_TAI) { 310 if (ntv->constant > 0) /* XXX zero & negative numbers ? */ 311 time_tai = ntv->constant; 312 } 313 #ifdef PPS_SYNC 314 if (modes & MOD_PPSMAX) { 315 if (ntv->shift < PPS_FAVG) 316 pps_shiftmax = PPS_FAVG; 317 else if (ntv->shift > PPS_FAVGMAX) 318 pps_shiftmax = PPS_FAVGMAX; 319 else 320 pps_shiftmax = ntv->shift; 321 } 322 #endif /* PPS_SYNC */ 323 if (modes & MOD_NANO) 324 time_status |= STA_NANO; 325 if (modes & MOD_MICRO) 326 time_status &= ~STA_NANO; 327 if (modes & MOD_CLKB) 328 time_status |= STA_CLK; 329 if (modes & MOD_CLKA) 330 time_status &= ~STA_CLK; 331 if (modes & MOD_FREQUENCY) { 332 freq = (ntv->freq * 1000LL) >> 16; 333 if (freq > MAXFREQ) 334 L_LINT(time_freq, MAXFREQ); 335 else if (freq < -MAXFREQ) 336 L_LINT(time_freq, -MAXFREQ); 337 else { 338 /* 339 * ntv.freq is [PPM * 2^16] = [us/s * 2^16] 340 * time_freq is [ns/s * 2^32] 341 */ 342 time_freq = ntv->freq * 1000LL * 65536LL; 343 } 344 #ifdef PPS_SYNC 345 pps_freq = time_freq; 346 #endif /* PPS_SYNC */ 347 } 348 if (modes & MOD_OFFSET) { 349 if (time_status & STA_NANO) 350 hardupdate(ntv->offset); 351 else 352 hardupdate(ntv->offset * 1000); 353 } 354 355 /* 356 * Retrieve all clock variables. Note that the TAI offset is 357 * returned only by ntp_gettime(); 358 */ 359 if (time_status & STA_NANO) 360 ntv->offset = L_GINT(time_offset); 361 else 362 ntv->offset = L_GINT(time_offset) / 1000; /* XXX rounding ? */ 363 ntv->freq = L_GINT((time_freq / 1000LL) << 16); 364 ntv->maxerror = time_maxerror; 365 ntv->esterror = time_esterror; 366 ntv->status = time_status; 367 ntv->constant = time_constant; 368 if (time_status & STA_NANO) 369 ntv->precision = time_precision; 370 else 371 ntv->precision = time_precision / 1000; 372 ntv->tolerance = MAXFREQ * SCALE_PPM; 373 #ifdef PPS_SYNC 374 ntv->shift = pps_shift; 375 ntv->ppsfreq = L_GINT((pps_freq / 1000LL) << 16); 376 if (time_status & STA_NANO) 377 ntv->jitter = pps_jitter; 378 else 379 ntv->jitter = pps_jitter / 1000; 380 ntv->stabil = pps_stabil; 381 ntv->calcnt = pps_calcnt; 382 ntv->errcnt = pps_errcnt; 383 ntv->jitcnt = pps_jitcnt; 384 ntv->stbcnt = pps_stbcnt; 385 #endif /* PPS_SYNC */ 386 splx(s); 387 } 388 #endif /* NTP */ 389 390 /* 391 * second_overflow() - called after ntp_tick_adjust() 392 * 393 * This routine is ordinarily called immediately following the above 394 * routine ntp_tick_adjust(). While these two routines are normally 395 * combined, they are separated here only for the purposes of 396 * simulation. 397 */ 398 void 399 ntp_update_second(int64_t *adjustment, time_t *newsec) 400 { 401 int tickrate; 402 l_fp ftemp; /* 32/64-bit temporary */ 403 404 #ifdef NTP 405 406 /* 407 * On rollover of the second both the nanosecond and microsecond 408 * clocks are updated and the state machine cranked as 409 * necessary. The phase adjustment to be used for the next 410 * second is calculated and the maximum error is increased by 411 * the tolerance. 412 */ 413 time_maxerror += MAXFREQ / 1000; 414 415 /* 416 * Leap second processing. If in leap-insert state at 417 * the end of the day, the system clock is set back one 418 * second; if in leap-delete state, the system clock is 419 * set ahead one second. The nano_time() routine or 420 * external clock driver will insure that reported time 421 * is always monotonic. 422 */ 423 switch (time_state) { 424 425 /* 426 * No warning. 427 */ 428 case TIME_OK: 429 if (time_status & STA_INS) 430 time_state = TIME_INS; 431 else if (time_status & STA_DEL) 432 time_state = TIME_DEL; 433 break; 434 435 /* 436 * Insert second 23:59:60 following second 437 * 23:59:59. 438 */ 439 case TIME_INS: 440 if (!(time_status & STA_INS)) 441 time_state = TIME_OK; 442 else if ((*newsec) % 86400 == 0) { 443 (*newsec)--; 444 time_state = TIME_OOP; 445 time_tai++; 446 } 447 break; 448 449 /* 450 * Delete second 23:59:59. 451 */ 452 case TIME_DEL: 453 if (!(time_status & STA_DEL)) 454 time_state = TIME_OK; 455 else if (((*newsec) + 1) % 86400 == 0) { 456 (*newsec)++; 457 time_tai--; 458 time_state = TIME_WAIT; 459 } 460 break; 461 462 /* 463 * Insert second in progress. 464 */ 465 case TIME_OOP: 466 time_state = TIME_WAIT; 467 break; 468 469 /* 470 * Wait for status bits to clear. 471 */ 472 case TIME_WAIT: 473 if (!(time_status & (STA_INS | STA_DEL))) 474 time_state = TIME_OK; 475 } 476 477 /* 478 * Compute the total time adjustment for the next second 479 * in ns. The offset is reduced by a factor depending on 480 * whether the PPS signal is operating. Note that the 481 * value is in effect scaled by the clock frequency, 482 * since the adjustment is added at each tick interrupt. 483 */ 484 ftemp = time_offset; 485 #ifdef PPS_SYNC 486 /* XXX even if PPS signal dies we should finish adjustment ? */ 487 if (time_status & STA_PPSTIME && time_status & 488 STA_PPSSIGNAL) 489 L_RSHIFT(ftemp, pps_shift); 490 else 491 L_RSHIFT(ftemp, SHIFT_PLL + time_constant); 492 #else 493 L_RSHIFT(ftemp, SHIFT_PLL + time_constant); 494 #endif /* PPS_SYNC */ 495 time_adj = ftemp; 496 L_SUB(time_offset, ftemp); 497 L_ADD(time_adj, time_freq); 498 499 #ifdef PPS_SYNC 500 if (pps_valid > 0) 501 pps_valid--; 502 else 503 time_status &= ~STA_PPSSIGNAL; 504 #endif /* PPS_SYNC */ 505 #else /* !NTP */ 506 do { if (&newsec) {} } while (/* CONSTCOND */ 0); /* quiet -Wunused */ 507 L_CLR(time_adj); 508 #endif /* !NTP */ 509 510 /* 511 * Apply any correction from adjtime(2). If more than one second 512 * off we slew at a rate of 5ms/s (5000 PPM) else 500us/s (500PPM) 513 * until the last second is slewed the final < 500 usecs. 514 */ 515 if (time_adjtime != 0) { 516 if (time_adjtime > 1000000) 517 tickrate = 5000; 518 else if (time_adjtime < -1000000) 519 tickrate = -5000; 520 else if (time_adjtime > 500) 521 tickrate = 500; 522 else if (time_adjtime < -500) 523 tickrate = -500; 524 else 525 tickrate = time_adjtime; 526 time_adjtime -= tickrate; 527 L_LINT(ftemp, tickrate * 1000); 528 L_ADD(time_adj, ftemp); 529 } 530 *adjustment = time_adj; 531 } 532 533 /* 534 * ntp_init() - initialize variables and structures 535 * 536 * This routine must be called after the kernel variables hz and tick 537 * are set or changed and before the next tick interrupt. In this 538 * particular implementation, these values are assumed set elsewhere in 539 * the kernel. The design allows the clock frequency and tick interval 540 * to be changed while the system is running. So, this routine should 541 * probably be integrated with the code that does that. 542 */ 543 void 544 ntp_init(void) 545 { 546 547 /* 548 * The following variables are initialized only at startup. Only 549 * those structures not cleared by the compiler need to be 550 * initialized, and these only in the simulator. In the actual 551 * kernel, any nonzero values here will quickly evaporate. 552 */ 553 L_CLR(time_adj); 554 #ifdef NTP 555 L_CLR(time_offset); 556 L_CLR(time_freq); 557 #ifdef PPS_SYNC 558 pps_tf[0].tv_sec = pps_tf[0].tv_nsec = 0; 559 pps_tf[1].tv_sec = pps_tf[1].tv_nsec = 0; 560 pps_tf[2].tv_sec = pps_tf[2].tv_nsec = 0; 561 pps_fcount = 0; 562 L_CLR(pps_freq); 563 #endif /* PPS_SYNC */ 564 #endif 565 } 566 567 #ifdef NTP 568 /* 569 * hardupdate() - local clock update 570 * 571 * This routine is called by ntp_adjtime() to update the local clock 572 * phase and frequency. The implementation is of an adaptive-parameter, 573 * hybrid phase/frequency-lock loop (PLL/FLL). The routine computes new 574 * time and frequency offset estimates for each call. If the kernel PPS 575 * discipline code is configured (PPS_SYNC), the PPS signal itself 576 * determines the new time offset, instead of the calling argument. 577 * Presumably, calls to ntp_adjtime() occur only when the caller 578 * believes the local clock is valid within some bound (+-128 ms with 579 * NTP). If the caller's time is far different than the PPS time, an 580 * argument will ensue, and it's not clear who will lose. 581 * 582 * For uncompensated quartz crystal oscillators and nominal update 583 * intervals less than 256 s, operation should be in phase-lock mode, 584 * where the loop is disciplined to phase. For update intervals greater 585 * than 1024 s, operation should be in frequency-lock mode, where the 586 * loop is disciplined to frequency. Between 256 s and 1024 s, the mode 587 * is selected by the STA_MODE status bit. 588 * 589 * Note: splclock() is in effect. 590 */ 591 void 592 hardupdate(long offset) 593 { 594 long mtemp; 595 l_fp ftemp; 596 597 /* 598 * Select how the phase is to be controlled and from which 599 * source. If the PPS signal is present and enabled to 600 * discipline the time, the PPS offset is used; otherwise, the 601 * argument offset is used. 602 */ 603 if (!(time_status & STA_PLL)) 604 return; 605 if (!(time_status & STA_PPSTIME && time_status & 606 STA_PPSSIGNAL)) { 607 if (offset > MAXPHASE) 608 time_monitor = MAXPHASE; 609 else if (offset < -MAXPHASE) 610 time_monitor = -MAXPHASE; 611 else 612 time_monitor = offset; 613 L_LINT(time_offset, time_monitor); 614 } 615 616 /* 617 * Select how the frequency is to be controlled and in which 618 * mode (PLL or FLL). If the PPS signal is present and enabled 619 * to discipline the frequency, the PPS frequency is used; 620 * otherwise, the argument offset is used to compute it. 621 */ 622 if (time_status & STA_PPSFREQ && time_status & STA_PPSSIGNAL) { 623 time_reftime = time_second; 624 return; 625 } 626 if (time_status & STA_FREQHOLD || time_reftime == 0) 627 time_reftime = time_second; 628 mtemp = time_second - time_reftime; 629 L_LINT(ftemp, time_monitor); 630 L_RSHIFT(ftemp, (SHIFT_PLL + 2 + time_constant) << 1); 631 L_MPY(ftemp, mtemp); 632 L_ADD(time_freq, ftemp); 633 time_status &= ~STA_MODE; 634 if (mtemp >= MINSEC && (time_status & STA_FLL || mtemp > 635 MAXSEC)) { 636 L_LINT(ftemp, (time_monitor << 4) / mtemp); 637 L_RSHIFT(ftemp, SHIFT_FLL + 4); 638 L_ADD(time_freq, ftemp); 639 time_status |= STA_MODE; 640 } 641 time_reftime = time_second; 642 if (L_GINT(time_freq) > MAXFREQ) 643 L_LINT(time_freq, MAXFREQ); 644 else if (L_GINT(time_freq) < -MAXFREQ) 645 L_LINT(time_freq, -MAXFREQ); 646 } 647 648 #ifdef PPS_SYNC 649 /* 650 * hardpps() - discipline CPU clock oscillator to external PPS signal 651 * 652 * This routine is called at each PPS interrupt in order to discipline 653 * the CPU clock oscillator to the PPS signal. It measures the PPS phase 654 * and leaves it in a handy spot for the hardclock() routine. It 655 * integrates successive PPS phase differences and calculates the 656 * frequency offset. This is used in hardclock() to discipline the CPU 657 * clock oscillator so that intrinsic frequency error is cancelled out. 658 * The code requires the caller to capture the time and hardware counter 659 * value at the on-time PPS signal transition. 660 * 661 * Note that, on some Unix systems, this routine runs at an interrupt 662 * priority level higher than the timer interrupt routine hardclock(). 663 * Therefore, the variables used are distinct from the hardclock() 664 * variables, except for certain exceptions: The PPS frequency pps_freq 665 * and phase pps_offset variables are determined by this routine and 666 * updated atomically. The time_tolerance variable can be considered a 667 * constant, since it is infrequently changed, and then only when the 668 * PPS signal is disabled. The watchdog counter pps_valid is updated 669 * once per second by hardclock() and is atomically cleared in this 670 * routine. 671 */ 672 void 673 hardpps(struct timespec *tsp, /* time at PPS */ 674 long nsec /* hardware counter at PPS */) 675 { 676 long u_sec, u_nsec, v_nsec; /* temps */ 677 l_fp ftemp; 678 679 /* 680 * The signal is first processed by a range gate and frequency 681 * discriminator. The range gate rejects noise spikes outside 682 * the range +-500 us. The frequency discriminator rejects input 683 * signals with apparent frequency outside the range 1 +-500 684 * PPM. If two hits occur in the same second, we ignore the 685 * later hit; if not and a hit occurs outside the range gate, 686 * keep the later hit for later comparison, but do not process 687 * it. 688 */ 689 time_status |= STA_PPSSIGNAL | STA_PPSJITTER; 690 time_status &= ~(STA_PPSWANDER | STA_PPSERROR); 691 pps_valid = PPS_VALID; 692 u_sec = tsp->tv_sec; 693 u_nsec = tsp->tv_nsec; 694 if (u_nsec >= (NANOSECOND >> 1)) { 695 u_nsec -= NANOSECOND; 696 u_sec++; 697 } 698 v_nsec = u_nsec - pps_tf[0].tv_nsec; 699 if (u_sec == pps_tf[0].tv_sec && v_nsec < NANOSECOND - 700 MAXFREQ) 701 return; 702 pps_tf[2] = pps_tf[1]; 703 pps_tf[1] = pps_tf[0]; 704 pps_tf[0].tv_sec = u_sec; 705 pps_tf[0].tv_nsec = u_nsec; 706 707 /* 708 * Compute the difference between the current and previous 709 * counter values. If the difference exceeds 0.5 s, assume it 710 * has wrapped around, so correct 1.0 s. If the result exceeds 711 * the tick interval, the sample point has crossed a tick 712 * boundary during the last second, so correct the tick. Very 713 * intricate. 714 */ 715 u_nsec = nsec; 716 if (u_nsec > (NANOSECOND >> 1)) 717 u_nsec -= NANOSECOND; 718 else if (u_nsec < -(NANOSECOND >> 1)) 719 u_nsec += NANOSECOND; 720 pps_fcount += u_nsec; 721 if (v_nsec > MAXFREQ || v_nsec < -MAXFREQ) 722 return; 723 time_status &= ~STA_PPSJITTER; 724 725 /* 726 * A three-stage median filter is used to help denoise the PPS 727 * time. The median sample becomes the time offset estimate; the 728 * difference between the other two samples becomes the time 729 * dispersion (jitter) estimate. 730 */ 731 if (pps_tf[0].tv_nsec > pps_tf[1].tv_nsec) { 732 if (pps_tf[1].tv_nsec > pps_tf[2].tv_nsec) { 733 v_nsec = pps_tf[1].tv_nsec; /* 0 1 2 */ 734 u_nsec = pps_tf[0].tv_nsec - pps_tf[2].tv_nsec; 735 } else if (pps_tf[2].tv_nsec > pps_tf[0].tv_nsec) { 736 v_nsec = pps_tf[0].tv_nsec; /* 2 0 1 */ 737 u_nsec = pps_tf[2].tv_nsec - pps_tf[1].tv_nsec; 738 } else { 739 v_nsec = pps_tf[2].tv_nsec; /* 0 2 1 */ 740 u_nsec = pps_tf[0].tv_nsec - pps_tf[1].tv_nsec; 741 } 742 } else { 743 if (pps_tf[1].tv_nsec < pps_tf[2].tv_nsec) { 744 v_nsec = pps_tf[1].tv_nsec; /* 2 1 0 */ 745 u_nsec = pps_tf[2].tv_nsec - pps_tf[0].tv_nsec; 746 } else if (pps_tf[2].tv_nsec < pps_tf[0].tv_nsec) { 747 v_nsec = pps_tf[0].tv_nsec; /* 1 0 2 */ 748 u_nsec = pps_tf[1].tv_nsec - pps_tf[2].tv_nsec; 749 } else { 750 v_nsec = pps_tf[2].tv_nsec; /* 1 2 0 */ 751 u_nsec = pps_tf[1].tv_nsec - pps_tf[0].tv_nsec; 752 } 753 } 754 755 /* 756 * Nominal jitter is due to PPS signal noise and interrupt 757 * latency. If it exceeds the popcorn threshold, the sample is 758 * discarded. otherwise, if so enabled, the time offset is 759 * updated. We can tolerate a modest loss of data here without 760 * much degrading time accuracy. 761 */ 762 if (u_nsec > (pps_jitter << PPS_POPCORN)) { 763 time_status |= STA_PPSJITTER; 764 pps_jitcnt++; 765 } else if (time_status & STA_PPSTIME) { 766 time_monitor = -v_nsec; 767 L_LINT(time_offset, time_monitor); 768 } 769 pps_jitter += (u_nsec - pps_jitter) >> PPS_FAVG; 770 u_sec = pps_tf[0].tv_sec - pps_lastsec; 771 if (u_sec < (1 << pps_shift)) 772 return; 773 774 /* 775 * At the end of the calibration interval the difference between 776 * the first and last counter values becomes the scaled 777 * frequency. It will later be divided by the length of the 778 * interval to determine the frequency update. If the frequency 779 * exceeds a sanity threshold, or if the actual calibration 780 * interval is not equal to the expected length, the data are 781 * discarded. We can tolerate a modest loss of data here without 782 * much degrading frequency accuracy. 783 */ 784 pps_calcnt++; 785 v_nsec = -pps_fcount; 786 pps_lastsec = pps_tf[0].tv_sec; 787 pps_fcount = 0; 788 u_nsec = MAXFREQ << pps_shift; 789 if (v_nsec > u_nsec || v_nsec < -u_nsec || u_sec != (1 << 790 pps_shift)) { 791 time_status |= STA_PPSERROR; 792 pps_errcnt++; 793 return; 794 } 795 796 /* 797 * Here the raw frequency offset and wander (stability) is 798 * calculated. If the wander is less than the wander threshold 799 * for four consecutive averaging intervals, the interval is 800 * doubled; if it is greater than the threshold for four 801 * consecutive intervals, the interval is halved. The scaled 802 * frequency offset is converted to frequency offset. The 803 * stability metric is calculated as the average of recent 804 * frequency changes, but is used only for performance 805 * monitoring. 806 */ 807 L_LINT(ftemp, v_nsec); 808 L_RSHIFT(ftemp, pps_shift); 809 L_SUB(ftemp, pps_freq); 810 u_nsec = L_GINT(ftemp); 811 if (u_nsec > PPS_MAXWANDER) { 812 L_LINT(ftemp, PPS_MAXWANDER); 813 pps_intcnt--; 814 time_status |= STA_PPSWANDER; 815 pps_stbcnt++; 816 } else if (u_nsec < -PPS_MAXWANDER) { 817 L_LINT(ftemp, -PPS_MAXWANDER); 818 pps_intcnt--; 819 time_status |= STA_PPSWANDER; 820 pps_stbcnt++; 821 } else { 822 pps_intcnt++; 823 } 824 if (pps_intcnt >= 4) { 825 pps_intcnt = 4; 826 if (pps_shift < pps_shiftmax) { 827 pps_shift++; 828 pps_intcnt = 0; 829 } 830 } else if (pps_intcnt <= -4 || pps_shift > pps_shiftmax) { 831 pps_intcnt = -4; 832 if (pps_shift > PPS_FAVG) { 833 pps_shift--; 834 pps_intcnt = 0; 835 } 836 } 837 if (u_nsec < 0) 838 u_nsec = -u_nsec; 839 pps_stabil += (u_nsec * SCALE_PPM - pps_stabil) >> PPS_FAVG; 840 841 /* 842 * The PPS frequency is recalculated and clamped to the maximum 843 * MAXFREQ. If enabled, the system clock frequency is updated as 844 * well. 845 */ 846 L_ADD(pps_freq, ftemp); 847 u_nsec = L_GINT(pps_freq); 848 if (u_nsec > MAXFREQ) 849 L_LINT(pps_freq, MAXFREQ); 850 else if (u_nsec < -MAXFREQ) 851 L_LINT(pps_freq, -MAXFREQ); 852 if (time_status & STA_PPSFREQ) 853 time_freq = pps_freq; 854 } 855 #endif /* PPS_SYNC */ 856 #endif /* NTP */ 857 #else /* !__HAVE_TIMECOUNTER */ 858 /****************************************************************************** 859 * * 860 * Copyright (c) David L. Mills 1993, 1994 * 861 * * 862 * Permission to use, copy, modify, and distribute this software and its * 863 * documentation for any purpose and without fee is hereby granted, provided * 864 * that the above copyright notice appears in all copies and that both the * 865 * copyright notice and this permission notice appear in supporting * 866 * documentation, and that the name University of Delaware not be used in * 867 * advertising or publicity pertaining to distribution of the software * 868 * without specific, written prior permission. The University of Delaware * 869 * makes no representations about the suitability this software for any * 870 * purpose. It is provided "as is" without express or implied warranty. * 871 * * 872 ******************************************************************************/ 873 874 /* 875 * Modification history kern_ntptime.c 876 * 877 * 24 Sep 94 David L. Mills 878 * Tightened code at exits. 879 * 880 * 24 Mar 94 David L. Mills 881 * Revised syscall interface to include new variables for PPS 882 * time discipline. 883 * 884 * 14 Feb 94 David L. Mills 885 * Added code for external clock 886 * 887 * 28 Nov 93 David L. Mills 888 * Revised frequency scaling to conform with adjusted parameters 889 * 890 * 17 Sep 93 David L. Mills 891 * Created file 892 */ 893 /* 894 * ntp_gettime(), ntp_adjtime() - precision time interface for SunOS 895 * V4.1.1 and V4.1.3 896 * 897 * These routines consitute the Network Time Protocol (NTP) interfaces 898 * for user and daemon application programs. The ntp_gettime() routine 899 * provides the time, maximum error (synch distance) and estimated error 900 * (dispersion) to client user application programs. The ntp_adjtime() 901 * routine is used by the NTP daemon to adjust the system clock to an 902 * externally derived time. The time offset and related variables set by 903 * this routine are used by hardclock() to adjust the phase and 904 * frequency of the phase-lock loop which controls the system clock. 905 */ 906 907 #include <sys/cdefs.h> 908 __KERNEL_RCSID(0, "$NetBSD: kern_ntptime.c,v 1.39 2006/10/13 16:53:36 dogcow Exp $"); 909 910 #include "opt_ntp.h" 911 #include "opt_compat_netbsd.h" 912 913 #include <sys/param.h> 914 #include <sys/resourcevar.h> 915 #include <sys/systm.h> 916 #include <sys/kernel.h> 917 #include <sys/proc.h> 918 #include <sys/sysctl.h> 919 #include <sys/timex.h> 920 #ifdef COMPAT_30 921 #include <compat/sys/timex.h> 922 #endif 923 #include <sys/vnode.h> 924 #include <sys/kauth.h> 925 926 #include <sys/mount.h> 927 #include <sys/sa.h> 928 #include <sys/syscallargs.h> 929 930 #include <machine/cpu.h> 931 932 #ifdef NTP 933 /* 934 * The following variables are used by the hardclock() routine in the 935 * kern_clock.c module and are described in that module. 936 */ 937 extern int time_state; /* clock state */ 938 extern int time_status; /* clock status bits */ 939 extern long time_offset; /* time adjustment (us) */ 940 extern long time_freq; /* frequency offset (scaled ppm) */ 941 extern long time_maxerror; /* maximum error (us) */ 942 extern long time_esterror; /* estimated error (us) */ 943 extern long time_constant; /* pll time constant */ 944 extern long time_precision; /* clock precision (us) */ 945 extern long time_tolerance; /* frequency tolerance (scaled ppm) */ 946 extern int time_adjusted; /* ntp might have changed the system time */ 947 948 #ifdef PPS_SYNC 949 /* 950 * The following variables are used only if the PPS signal discipline 951 * is configured in the kernel. 952 */ 953 extern int pps_shift; /* interval duration (s) (shift) */ 954 extern long pps_freq; /* pps frequency offset (scaled ppm) */ 955 extern long pps_jitter; /* pps jitter (us) */ 956 extern long pps_stabil; /* pps stability (scaled ppm) */ 957 extern long pps_jitcnt; /* jitter limit exceeded */ 958 extern long pps_calcnt; /* calibration intervals */ 959 extern long pps_errcnt; /* calibration errors */ 960 extern long pps_stbcnt; /* stability limit exceeded */ 961 #endif /* PPS_SYNC */ 962 963 /*ARGSUSED*/ 964 /* 965 * ntp_gettime() - NTP user application interface 966 */ 967 void 968 ntp_gettime(ntvp) 969 struct ntptimeval *ntvp; 970 { 971 struct timeval atv; 972 int s; 973 974 memset(ntvp, 0, sizeof(struct ntptimeval)); 975 976 s = splclock(); 977 #ifdef EXT_CLOCK 978 /* 979 * The microtime() external clock routine returns a 980 * status code. If less than zero, we declare an error 981 * in the clock status word and return the kernel 982 * (software) time variable. While there are other 983 * places that call microtime(), this is the only place 984 * that matters from an application point of view. 985 */ 986 if (microtime(&atv) < 0) { 987 time_status |= STA_CLOCKERR; 988 ntvp->time = time; 989 } else 990 time_status &= ~STA_CLOCKERR; 991 #else /* EXT_CLOCK */ 992 microtime(&atv); 993 #endif /* EXT_CLOCK */ 994 ntvp->maxerror = time_maxerror; 995 ntvp->esterror = time_esterror; 996 (void) splx(s); 997 TIMEVAL_TO_TIMESPEC(&atv, &ntvp->time); 998 } 999 1000 1001 /* ARGSUSED */ 1002 /* 1003 * ntp_adjtime() - NTP daemon application interface 1004 */ 1005 int 1006 sys_ntp_adjtime(l, v, retval) 1007 struct lwp *l; 1008 void *v; 1009 register_t *retval; 1010 { 1011 struct sys_ntp_adjtime_args /* { 1012 syscallarg(struct timex *) tp; 1013 } */ *uap = v; 1014 struct timex ntv; 1015 int error = 0; 1016 1017 error = copyin((caddr_t)SCARG(uap, tp), (caddr_t)&ntv, sizeof(ntv)); 1018 if (error != 0) 1019 return (error); 1020 1021 if (ntv.modes != 0 && (error = kauth_authorize_system(l->l_cred, 1022 KAUTH_SYSTEM_TIME, KAUTH_REQ_SYSTEM_TIME_NTPADJTIME, NULL, 1023 NULL, NULL)) != 0) 1024 return (error); 1025 1026 ntp_adjtime1(&ntv); 1027 1028 error = copyout((caddr_t)&ntv, (caddr_t)SCARG(uap, tp), sizeof(ntv)); 1029 if (error == 0) 1030 *retval = ntp_timestatus(); 1031 1032 return error; 1033 } 1034 1035 void 1036 ntp_adjtime1(ntv) 1037 struct timex *ntv; 1038 { 1039 int modes; 1040 int s; 1041 1042 /* 1043 * Update selected clock variables. Note that there is no error 1044 * checking here on the assumption the superuser should know 1045 * what it is doing. 1046 */ 1047 modes = ntv->modes; 1048 if (modes != 0) 1049 /* We need to save the system time during shutdown */ 1050 time_adjusted |= 2; 1051 s = splclock(); 1052 if (modes & MOD_FREQUENCY) 1053 #ifdef PPS_SYNC 1054 time_freq = ntv->freq - pps_freq; 1055 #else /* PPS_SYNC */ 1056 time_freq = ntv->freq; 1057 #endif /* PPS_SYNC */ 1058 if (modes & MOD_MAXERROR) 1059 time_maxerror = ntv->maxerror; 1060 if (modes & MOD_ESTERROR) 1061 time_esterror = ntv->esterror; 1062 if (modes & MOD_STATUS) { 1063 time_status &= STA_RONLY; 1064 time_status |= ntv->status & ~STA_RONLY; 1065 } 1066 if (modes & MOD_TIMECONST) 1067 time_constant = ntv->constant; 1068 if (modes & MOD_OFFSET) 1069 hardupdate(ntv->offset); 1070 1071 /* 1072 * Retrieve all clock variables 1073 */ 1074 if (time_offset < 0) 1075 ntv->offset = -(-time_offset >> SHIFT_UPDATE); 1076 else 1077 ntv->offset = time_offset >> SHIFT_UPDATE; 1078 #ifdef PPS_SYNC 1079 ntv->freq = time_freq + pps_freq; 1080 #else /* PPS_SYNC */ 1081 ntv->freq = time_freq; 1082 #endif /* PPS_SYNC */ 1083 ntv->maxerror = time_maxerror; 1084 ntv->esterror = time_esterror; 1085 ntv->status = time_status; 1086 ntv->constant = time_constant; 1087 ntv->precision = time_precision; 1088 ntv->tolerance = time_tolerance; 1089 #ifdef PPS_SYNC 1090 ntv->shift = pps_shift; 1091 ntv->ppsfreq = pps_freq; 1092 ntv->jitter = pps_jitter >> PPS_AVG; 1093 ntv->stabil = pps_stabil; 1094 ntv->calcnt = pps_calcnt; 1095 ntv->errcnt = pps_errcnt; 1096 ntv->jitcnt = pps_jitcnt; 1097 ntv->stbcnt = pps_stbcnt; 1098 #endif /* PPS_SYNC */ 1099 (void)splx(s); 1100 } 1101 #endif /* NTP */ 1102 #endif /* !__HAVE_TIMECOUNTER */ 1103 1104 #ifdef NTP 1105 int 1106 ntp_timestatus() 1107 { 1108 /* 1109 * Status word error decode. If any of these conditions 1110 * occur, an error is returned, instead of the status 1111 * word. Most applications will care only about the fact 1112 * the system clock may not be trusted, not about the 1113 * details. 1114 * 1115 * Hardware or software error 1116 */ 1117 if ((time_status & (STA_UNSYNC | STA_CLOCKERR)) || 1118 1119 /* 1120 * PPS signal lost when either time or frequency 1121 * synchronization requested 1122 */ 1123 (time_status & (STA_PPSFREQ | STA_PPSTIME) && 1124 !(time_status & STA_PPSSIGNAL)) || 1125 1126 /* 1127 * PPS jitter exceeded when time synchronization 1128 * requested 1129 */ 1130 (time_status & STA_PPSTIME && 1131 time_status & STA_PPSJITTER) || 1132 1133 /* 1134 * PPS wander exceeded or calibration error when 1135 * frequency synchronization requested 1136 */ 1137 (time_status & STA_PPSFREQ && 1138 time_status & (STA_PPSWANDER | STA_PPSERROR))) 1139 return (TIME_ERROR); 1140 else 1141 return (time_state); 1142 } 1143 1144 /*ARGSUSED*/ 1145 /* 1146 * ntp_gettime() - NTP user application interface 1147 */ 1148 int 1149 sys___ntp_gettime30(struct lwp *l __unused, void *v, register_t *retval) 1150 { 1151 struct sys___ntp_gettime30_args /* { 1152 syscallarg(struct ntptimeval *) ntvp; 1153 } */ *uap = v; 1154 struct ntptimeval ntv; 1155 int error = 0; 1156 1157 if (SCARG(uap, ntvp)) { 1158 ntp_gettime(&ntv); 1159 1160 error = copyout((caddr_t)&ntv, (caddr_t)SCARG(uap, ntvp), 1161 sizeof(ntv)); 1162 } 1163 if (!error) { 1164 *retval = ntp_timestatus(); 1165 } 1166 return(error); 1167 } 1168 1169 #ifdef COMPAT_30 1170 int 1171 compat_30_sys_ntp_gettime(struct lwp *l __unused, void *v, register_t *retval) 1172 { 1173 struct compat_30_sys_ntp_gettime_args /* { 1174 syscallarg(struct ntptimeval30 *) ontvp; 1175 } */ *uap = v; 1176 struct ntptimeval ntv; 1177 struct ntptimeval30 ontv; 1178 int error = 0; 1179 1180 if (SCARG(uap, ntvp)) { 1181 ntp_gettime(&ntv); 1182 TIMESPEC_TO_TIMEVAL(&ontv.time, &ntv.time); 1183 ontv.maxerror = ntv.maxerror; 1184 ontv.esterror = ntv.esterror; 1185 1186 error = copyout((caddr_t)&ontv, (caddr_t)SCARG(uap, ntvp), 1187 sizeof(ontv)); 1188 } 1189 if (!error) 1190 *retval = ntp_timestatus(); 1191 1192 return (error); 1193 } 1194 #endif 1195 1196 /* 1197 * return information about kernel precision timekeeping 1198 */ 1199 static int 1200 sysctl_kern_ntptime(SYSCTLFN_ARGS) 1201 { 1202 struct sysctlnode node; 1203 struct ntptimeval ntv; 1204 1205 ntp_gettime(&ntv); 1206 1207 node = *rnode; 1208 node.sysctl_data = &ntv; 1209 node.sysctl_size = sizeof(ntv); 1210 return (sysctl_lookup(SYSCTLFN_CALL(&node))); 1211 } 1212 1213 SYSCTL_SETUP(sysctl_kern_ntptime_setup, "sysctl kern.ntptime node setup") 1214 { 1215 1216 sysctl_createv(clog, 0, NULL, NULL, 1217 CTLFLAG_PERMANENT, 1218 CTLTYPE_NODE, "kern", NULL, 1219 NULL, 0, NULL, 0, 1220 CTL_KERN, CTL_EOL); 1221 1222 sysctl_createv(clog, 0, NULL, NULL, 1223 CTLFLAG_PERMANENT, 1224 CTLTYPE_STRUCT, "ntptime", 1225 SYSCTL_DESCR("Kernel clock values for NTP"), 1226 sysctl_kern_ntptime, 0, NULL, 1227 sizeof(struct ntptimeval), 1228 CTL_KERN, KERN_NTPTIME, CTL_EOL); 1229 } 1230 #else /* !NTP */ 1231 /* For some reason, raising SIGSYS (as sys_nosys would) is problematic. */ 1232 1233 int 1234 sys___ntp_gettime30(l, v, retval) 1235 struct lwp *l __unused; 1236 void *v __unused; 1237 register_t *retval __unused; 1238 { 1239 1240 return(ENOSYS); 1241 } 1242 1243 #ifdef COMPAT_30 1244 int 1245 compat_30_sys_ntp_gettime(l, v, retval) 1246 struct lwp *l __unused; 1247 void *v __unused; 1248 register_t *retval __unused; 1249 { 1250 1251 return(ENOSYS); 1252 } 1253 #endif 1254 #endif /* !NTP */ 1255