1 /* 2 * NTP state machine interfaces and logic. 3 * 4 * This code was mainly moved from kernel/timer.c and kernel/time.c 5 * Please see those files for relevant copyright info and historical 6 * changelogs. 7 */ 8 #include <linux/capability.h> 9 #include <linux/clocksource.h> 10 #include <linux/workqueue.h> 11 #include <linux/hrtimer.h> 12 #include <linux/jiffies.h> 13 #include <linux/math64.h> 14 #include <linux/timex.h> 15 #include <linux/time.h> 16 #include <linux/mm.h> 17 18 /* 19 * NTP timekeeping variables: 20 */ 21 22 /* USER_HZ period (usecs): */ 23 unsigned long tick_usec = TICK_USEC; 24 25 /* ACTHZ period (nsecs): */ 26 unsigned long tick_nsec; 27 28 u64 tick_length; 29 static u64 tick_length_base; 30 31 static struct hrtimer leap_timer; 32 33 #define MAX_TICKADJ 500LL /* usecs */ 34 #define MAX_TICKADJ_SCALED \ 35 (((MAX_TICKADJ * NSEC_PER_USEC) << NTP_SCALE_SHIFT) / NTP_INTERVAL_FREQ) 36 37 /* 38 * phase-lock loop variables 39 */ 40 41 /* 42 * clock synchronization status 43 * 44 * (TIME_ERROR prevents overwriting the CMOS clock) 45 */ 46 static int time_state = TIME_OK; 47 48 /* clock status bits: */ 49 int time_status = STA_UNSYNC; 50 51 /* TAI offset (secs): */ 52 static long time_tai; 53 54 /* time adjustment (nsecs): */ 55 static s64 time_offset; 56 57 /* pll time constant: */ 58 static long time_constant = 2; 59 60 /* maximum error (usecs): */ 61 long time_maxerror = NTP_PHASE_LIMIT; 62 63 /* estimated error (usecs): */ 64 long time_esterror = NTP_PHASE_LIMIT; 65 66 /* frequency offset (scaled nsecs/secs): */ 67 static s64 time_freq; 68 69 /* time at last adjustment (secs): */ 70 static long time_reftime; 71 72 long time_adjust; 73 74 /* constant (boot-param configurable) NTP tick adjustment (upscaled) */ 75 static s64 ntp_tick_adj; 76 77 /* 78 * NTP methods: 79 */ 80 81 /* 82 * Update (tick_length, tick_length_base, tick_nsec), based 83 * on (tick_usec, ntp_tick_adj, time_freq): 84 */ 85 static void ntp_update_frequency(void) 86 { 87 u64 second_length; 88 u64 new_base; 89 90 second_length = (u64)(tick_usec * NSEC_PER_USEC * USER_HZ) 91 << NTP_SCALE_SHIFT; 92 93 second_length += ntp_tick_adj; 94 second_length += time_freq; 95 96 tick_nsec = div_u64(second_length, HZ) >> NTP_SCALE_SHIFT; 97 new_base = div_u64(second_length, NTP_INTERVAL_FREQ); 98 99 /* 100 * Don't wait for the next second_overflow, apply 101 * the change to the tick length immediately: 102 */ 103 tick_length += new_base - tick_length_base; 104 tick_length_base = new_base; 105 } 106 107 static inline s64 ntp_update_offset_fll(s64 offset64, long secs) 108 { 109 time_status &= ~STA_MODE; 110 111 if (secs < MINSEC) 112 return 0; 113 114 if (!(time_status & STA_FLL) && (secs <= MAXSEC)) 115 return 0; 116 117 time_status |= STA_MODE; 118 119 return div_s64(offset64 << (NTP_SCALE_SHIFT - SHIFT_FLL), secs); 120 } 121 122 static void ntp_update_offset(long offset) 123 { 124 s64 freq_adj; 125 s64 offset64; 126 long secs; 127 128 if (!(time_status & STA_PLL)) 129 return; 130 131 if (!(time_status & STA_NANO)) 132 offset *= NSEC_PER_USEC; 133 134 /* 135 * Scale the phase adjustment and 136 * clamp to the operating range. 137 */ 138 offset = min(offset, MAXPHASE); 139 offset = max(offset, -MAXPHASE); 140 141 /* 142 * Select how the frequency is to be controlled 143 * and in which mode (PLL or FLL). 144 */ 145 secs = xtime.tv_sec - time_reftime; 146 if (unlikely(time_status & STA_FREQHOLD)) 147 secs = 0; 148 149 time_reftime = xtime.tv_sec; 150 151 offset64 = offset; 152 freq_adj = (offset64 * secs) << 153 (NTP_SCALE_SHIFT - 2 * (SHIFT_PLL + 2 + time_constant)); 154 155 freq_adj += ntp_update_offset_fll(offset64, secs); 156 157 freq_adj = min(freq_adj + time_freq, MAXFREQ_SCALED); 158 159 time_freq = max(freq_adj, -MAXFREQ_SCALED); 160 161 time_offset = div_s64(offset64 << NTP_SCALE_SHIFT, NTP_INTERVAL_FREQ); 162 } 163 164 /** 165 * ntp_clear - Clears the NTP state variables 166 * 167 * Must be called while holding a write on the xtime_lock 168 */ 169 void ntp_clear(void) 170 { 171 time_adjust = 0; /* stop active adjtime() */ 172 time_status |= STA_UNSYNC; 173 time_maxerror = NTP_PHASE_LIMIT; 174 time_esterror = NTP_PHASE_LIMIT; 175 176 ntp_update_frequency(); 177 178 tick_length = tick_length_base; 179 time_offset = 0; 180 } 181 182 /* 183 * Leap second processing. If in leap-insert state at the end of the 184 * day, the system clock is set back one second; if in leap-delete 185 * state, the system clock is set ahead one second. 186 */ 187 static enum hrtimer_restart ntp_leap_second(struct hrtimer *timer) 188 { 189 enum hrtimer_restart res = HRTIMER_NORESTART; 190 191 write_seqlock(&xtime_lock); 192 193 switch (time_state) { 194 case TIME_OK: 195 break; 196 case TIME_INS: 197 timekeeping_leap_insert(-1); 198 time_state = TIME_OOP; 199 printk(KERN_NOTICE 200 "Clock: inserting leap second 23:59:60 UTC\n"); 201 hrtimer_add_expires_ns(&leap_timer, NSEC_PER_SEC); 202 res = HRTIMER_RESTART; 203 break; 204 case TIME_DEL: 205 timekeeping_leap_insert(1); 206 time_tai--; 207 time_state = TIME_WAIT; 208 printk(KERN_NOTICE 209 "Clock: deleting leap second 23:59:59 UTC\n"); 210 break; 211 case TIME_OOP: 212 time_tai++; 213 time_state = TIME_WAIT; 214 /* fall through */ 215 case TIME_WAIT: 216 if (!(time_status & (STA_INS | STA_DEL))) 217 time_state = TIME_OK; 218 break; 219 } 220 221 write_sequnlock(&xtime_lock); 222 223 return res; 224 } 225 226 /* 227 * this routine handles the overflow of the microsecond field 228 * 229 * The tricky bits of code to handle the accurate clock support 230 * were provided by Dave Mills (Mills@UDEL.EDU) of NTP fame. 231 * They were originally developed for SUN and DEC kernels. 232 * All the kudos should go to Dave for this stuff. 233 */ 234 void second_overflow(void) 235 { 236 s64 delta; 237 238 /* Bump the maxerror field */ 239 time_maxerror += MAXFREQ / NSEC_PER_USEC; 240 if (time_maxerror > NTP_PHASE_LIMIT) { 241 time_maxerror = NTP_PHASE_LIMIT; 242 time_status |= STA_UNSYNC; 243 } 244 245 /* 246 * Compute the phase adjustment for the next second. The offset is 247 * reduced by a fixed factor times the time constant. 248 */ 249 tick_length = tick_length_base; 250 251 delta = shift_right(time_offset, SHIFT_PLL + time_constant); 252 time_offset -= delta; 253 tick_length += delta; 254 255 if (!time_adjust) 256 return; 257 258 if (time_adjust > MAX_TICKADJ) { 259 time_adjust -= MAX_TICKADJ; 260 tick_length += MAX_TICKADJ_SCALED; 261 return; 262 } 263 264 if (time_adjust < -MAX_TICKADJ) { 265 time_adjust += MAX_TICKADJ; 266 tick_length -= MAX_TICKADJ_SCALED; 267 return; 268 } 269 270 tick_length += (s64)(time_adjust * NSEC_PER_USEC / NTP_INTERVAL_FREQ) 271 << NTP_SCALE_SHIFT; 272 time_adjust = 0; 273 } 274 275 #ifdef CONFIG_GENERIC_CMOS_UPDATE 276 277 /* Disable the cmos update - used by virtualization and embedded */ 278 int no_sync_cmos_clock __read_mostly; 279 280 static void sync_cmos_clock(struct work_struct *work); 281 282 static DECLARE_DELAYED_WORK(sync_cmos_work, sync_cmos_clock); 283 284 static void sync_cmos_clock(struct work_struct *work) 285 { 286 struct timespec now, next; 287 int fail = 1; 288 289 /* 290 * If we have an externally synchronized Linux clock, then update 291 * CMOS clock accordingly every ~11 minutes. Set_rtc_mmss() has to be 292 * called as close as possible to 500 ms before the new second starts. 293 * This code is run on a timer. If the clock is set, that timer 294 * may not expire at the correct time. Thus, we adjust... 295 */ 296 if (!ntp_synced()) { 297 /* 298 * Not synced, exit, do not restart a timer (if one is 299 * running, let it run out). 300 */ 301 return; 302 } 303 304 getnstimeofday(&now); 305 if (abs(now.tv_nsec - (NSEC_PER_SEC / 2)) <= tick_nsec / 2) 306 fail = update_persistent_clock(now); 307 308 next.tv_nsec = (NSEC_PER_SEC / 2) - now.tv_nsec - (TICK_NSEC / 2); 309 if (next.tv_nsec <= 0) 310 next.tv_nsec += NSEC_PER_SEC; 311 312 if (!fail) 313 next.tv_sec = 659; 314 else 315 next.tv_sec = 0; 316 317 if (next.tv_nsec >= NSEC_PER_SEC) { 318 next.tv_sec++; 319 next.tv_nsec -= NSEC_PER_SEC; 320 } 321 schedule_delayed_work(&sync_cmos_work, timespec_to_jiffies(&next)); 322 } 323 324 static void notify_cmos_timer(void) 325 { 326 if (!no_sync_cmos_clock) 327 schedule_delayed_work(&sync_cmos_work, 0); 328 } 329 330 #else 331 static inline void notify_cmos_timer(void) { } 332 #endif 333 334 /* 335 * Start the leap seconds timer: 336 */ 337 static inline void ntp_start_leap_timer(struct timespec *ts) 338 { 339 long now = ts->tv_sec; 340 341 if (time_status & STA_INS) { 342 time_state = TIME_INS; 343 now += 86400 - now % 86400; 344 hrtimer_start(&leap_timer, ktime_set(now, 0), HRTIMER_MODE_ABS); 345 346 return; 347 } 348 349 if (time_status & STA_DEL) { 350 time_state = TIME_DEL; 351 now += 86400 - (now + 1) % 86400; 352 hrtimer_start(&leap_timer, ktime_set(now, 0), HRTIMER_MODE_ABS); 353 } 354 } 355 356 /* 357 * Propagate a new txc->status value into the NTP state: 358 */ 359 static inline void process_adj_status(struct timex *txc, struct timespec *ts) 360 { 361 if ((time_status & STA_PLL) && !(txc->status & STA_PLL)) { 362 time_state = TIME_OK; 363 time_status = STA_UNSYNC; 364 } 365 366 /* 367 * If we turn on PLL adjustments then reset the 368 * reference time to current time. 369 */ 370 if (!(time_status & STA_PLL) && (txc->status & STA_PLL)) 371 time_reftime = xtime.tv_sec; 372 373 /* only set allowed bits */ 374 time_status &= STA_RONLY; 375 time_status |= txc->status & ~STA_RONLY; 376 377 switch (time_state) { 378 case TIME_OK: 379 ntp_start_leap_timer(ts); 380 break; 381 case TIME_INS: 382 case TIME_DEL: 383 time_state = TIME_OK; 384 ntp_start_leap_timer(ts); 385 case TIME_WAIT: 386 if (!(time_status & (STA_INS | STA_DEL))) 387 time_state = TIME_OK; 388 break; 389 case TIME_OOP: 390 hrtimer_restart(&leap_timer); 391 break; 392 } 393 } 394 /* 395 * Called with the xtime lock held, so we can access and modify 396 * all the global NTP state: 397 */ 398 static inline void process_adjtimex_modes(struct timex *txc, struct timespec *ts) 399 { 400 if (txc->modes & ADJ_STATUS) 401 process_adj_status(txc, ts); 402 403 if (txc->modes & ADJ_NANO) 404 time_status |= STA_NANO; 405 406 if (txc->modes & ADJ_MICRO) 407 time_status &= ~STA_NANO; 408 409 if (txc->modes & ADJ_FREQUENCY) { 410 time_freq = txc->freq * PPM_SCALE; 411 time_freq = min(time_freq, MAXFREQ_SCALED); 412 time_freq = max(time_freq, -MAXFREQ_SCALED); 413 } 414 415 if (txc->modes & ADJ_MAXERROR) 416 time_maxerror = txc->maxerror; 417 418 if (txc->modes & ADJ_ESTERROR) 419 time_esterror = txc->esterror; 420 421 if (txc->modes & ADJ_TIMECONST) { 422 time_constant = txc->constant; 423 if (!(time_status & STA_NANO)) 424 time_constant += 4; 425 time_constant = min(time_constant, (long)MAXTC); 426 time_constant = max(time_constant, 0l); 427 } 428 429 if (txc->modes & ADJ_TAI && txc->constant > 0) 430 time_tai = txc->constant; 431 432 if (txc->modes & ADJ_OFFSET) 433 ntp_update_offset(txc->offset); 434 435 if (txc->modes & ADJ_TICK) 436 tick_usec = txc->tick; 437 438 if (txc->modes & (ADJ_TICK|ADJ_FREQUENCY|ADJ_OFFSET)) 439 ntp_update_frequency(); 440 } 441 442 /* 443 * adjtimex mainly allows reading (and writing, if superuser) of 444 * kernel time-keeping variables. used by xntpd. 445 */ 446 int do_adjtimex(struct timex *txc) 447 { 448 struct timespec ts; 449 int result; 450 451 /* Validate the data before disabling interrupts */ 452 if (txc->modes & ADJ_ADJTIME) { 453 /* singleshot must not be used with any other mode bits */ 454 if (!(txc->modes & ADJ_OFFSET_SINGLESHOT)) 455 return -EINVAL; 456 if (!(txc->modes & ADJ_OFFSET_READONLY) && 457 !capable(CAP_SYS_TIME)) 458 return -EPERM; 459 } else { 460 /* In order to modify anything, you gotta be super-user! */ 461 if (txc->modes && !capable(CAP_SYS_TIME)) 462 return -EPERM; 463 464 /* 465 * if the quartz is off by more than 10% then 466 * something is VERY wrong! 467 */ 468 if (txc->modes & ADJ_TICK && 469 (txc->tick < 900000/USER_HZ || 470 txc->tick > 1100000/USER_HZ)) 471 return -EINVAL; 472 473 if (txc->modes & ADJ_STATUS && time_state != TIME_OK) 474 hrtimer_cancel(&leap_timer); 475 } 476 477 getnstimeofday(&ts); 478 479 write_seqlock_irq(&xtime_lock); 480 481 if (txc->modes & ADJ_ADJTIME) { 482 long save_adjust = time_adjust; 483 484 if (!(txc->modes & ADJ_OFFSET_READONLY)) { 485 /* adjtime() is independent from ntp_adjtime() */ 486 time_adjust = txc->offset; 487 ntp_update_frequency(); 488 } 489 txc->offset = save_adjust; 490 } else { 491 492 /* If there are input parameters, then process them: */ 493 if (txc->modes) 494 process_adjtimex_modes(txc, &ts); 495 496 txc->offset = shift_right(time_offset * NTP_INTERVAL_FREQ, 497 NTP_SCALE_SHIFT); 498 if (!(time_status & STA_NANO)) 499 txc->offset /= NSEC_PER_USEC; 500 } 501 502 result = time_state; /* mostly `TIME_OK' */ 503 if (time_status & (STA_UNSYNC|STA_CLOCKERR)) 504 result = TIME_ERROR; 505 506 txc->freq = shift_right((time_freq >> PPM_SCALE_INV_SHIFT) * 507 PPM_SCALE_INV, NTP_SCALE_SHIFT); 508 txc->maxerror = time_maxerror; 509 txc->esterror = time_esterror; 510 txc->status = time_status; 511 txc->constant = time_constant; 512 txc->precision = 1; 513 txc->tolerance = MAXFREQ_SCALED / PPM_SCALE; 514 txc->tick = tick_usec; 515 txc->tai = time_tai; 516 517 /* PPS is not implemented, so these are zero */ 518 txc->ppsfreq = 0; 519 txc->jitter = 0; 520 txc->shift = 0; 521 txc->stabil = 0; 522 txc->jitcnt = 0; 523 txc->calcnt = 0; 524 txc->errcnt = 0; 525 txc->stbcnt = 0; 526 527 write_sequnlock_irq(&xtime_lock); 528 529 txc->time.tv_sec = ts.tv_sec; 530 txc->time.tv_usec = ts.tv_nsec; 531 if (!(time_status & STA_NANO)) 532 txc->time.tv_usec /= NSEC_PER_USEC; 533 534 notify_cmos_timer(); 535 536 return result; 537 } 538 539 static int __init ntp_tick_adj_setup(char *str) 540 { 541 ntp_tick_adj = simple_strtol(str, NULL, 0); 542 ntp_tick_adj <<= NTP_SCALE_SHIFT; 543 544 return 1; 545 } 546 547 __setup("ntp_tick_adj=", ntp_tick_adj_setup); 548 549 void __init ntp_init(void) 550 { 551 ntp_clear(); 552 hrtimer_init(&leap_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS); 553 leap_timer.function = ntp_leap_second; 554 } 555