1 /* 2 * linux/kernel/time/ntp.c 3 * 4 * NTP state machine interfaces and logic. 5 * 6 * This code was mainly moved from kernel/timer.c and kernel/time.c 7 * Please see those files for relevant copyright info and historical 8 * changelogs. 9 */ 10 11 #include <linux/mm.h> 12 #include <linux/time.h> 13 #include <linux/timer.h> 14 #include <linux/timex.h> 15 #include <linux/jiffies.h> 16 #include <linux/hrtimer.h> 17 #include <linux/capability.h> 18 #include <asm/div64.h> 19 #include <asm/timex.h> 20 21 /* 22 * Timekeeping variables 23 */ 24 unsigned long tick_usec = TICK_USEC; /* USER_HZ period (usec) */ 25 unsigned long tick_nsec; /* ACTHZ period (nsec) */ 26 static u64 tick_length, tick_length_base; 27 28 #define MAX_TICKADJ 500 /* microsecs */ 29 #define MAX_TICKADJ_SCALED (((u64)(MAX_TICKADJ * NSEC_PER_USEC) << \ 30 TICK_LENGTH_SHIFT) / NTP_INTERVAL_FREQ) 31 32 /* 33 * phase-lock loop variables 34 */ 35 /* TIME_ERROR prevents overwriting the CMOS clock */ 36 static int time_state = TIME_OK; /* clock synchronization status */ 37 int time_status = STA_UNSYNC; /* clock status bits */ 38 static s64 time_offset; /* time adjustment (ns) */ 39 static long time_constant = 2; /* pll time constant */ 40 long time_maxerror = NTP_PHASE_LIMIT; /* maximum error (us) */ 41 long time_esterror = NTP_PHASE_LIMIT; /* estimated error (us) */ 42 long time_freq; /* frequency offset (scaled ppm)*/ 43 static long time_reftime; /* time at last adjustment (s) */ 44 long time_adjust; 45 46 #define CLOCK_TICK_OVERFLOW (LATCH * HZ - CLOCK_TICK_RATE) 47 #define CLOCK_TICK_ADJUST (((s64)CLOCK_TICK_OVERFLOW * NSEC_PER_SEC) / \ 48 (s64)CLOCK_TICK_RATE) 49 50 static void ntp_update_frequency(void) 51 { 52 u64 second_length = (u64)(tick_usec * NSEC_PER_USEC * USER_HZ) 53 << TICK_LENGTH_SHIFT; 54 second_length += (s64)CLOCK_TICK_ADJUST << TICK_LENGTH_SHIFT; 55 second_length += (s64)time_freq << (TICK_LENGTH_SHIFT - SHIFT_NSEC); 56 57 tick_length_base = second_length; 58 59 do_div(second_length, HZ); 60 tick_nsec = second_length >> TICK_LENGTH_SHIFT; 61 62 do_div(tick_length_base, NTP_INTERVAL_FREQ); 63 } 64 65 /** 66 * ntp_clear - Clears the NTP state variables 67 * 68 * Must be called while holding a write on the xtime_lock 69 */ 70 void ntp_clear(void) 71 { 72 time_adjust = 0; /* stop active adjtime() */ 73 time_status |= STA_UNSYNC; 74 time_maxerror = NTP_PHASE_LIMIT; 75 time_esterror = NTP_PHASE_LIMIT; 76 77 ntp_update_frequency(); 78 79 tick_length = tick_length_base; 80 time_offset = 0; 81 } 82 83 /* 84 * this routine handles the overflow of the microsecond field 85 * 86 * The tricky bits of code to handle the accurate clock support 87 * were provided by Dave Mills (Mills@UDEL.EDU) of NTP fame. 88 * They were originally developed for SUN and DEC kernels. 89 * All the kudos should go to Dave for this stuff. 90 */ 91 void second_overflow(void) 92 { 93 long time_adj; 94 95 /* Bump the maxerror field */ 96 time_maxerror += MAXFREQ >> SHIFT_USEC; 97 if (time_maxerror > NTP_PHASE_LIMIT) { 98 time_maxerror = NTP_PHASE_LIMIT; 99 time_status |= STA_UNSYNC; 100 } 101 102 /* 103 * Leap second processing. If in leap-insert state at the end of the 104 * day, the system clock is set back one second; if in leap-delete 105 * state, the system clock is set ahead one second. The microtime() 106 * routine or external clock driver will insure that reported time is 107 * always monotonic. The ugly divides should be replaced. 108 */ 109 switch (time_state) { 110 case TIME_OK: 111 if (time_status & STA_INS) 112 time_state = TIME_INS; 113 else if (time_status & STA_DEL) 114 time_state = TIME_DEL; 115 break; 116 case TIME_INS: 117 if (xtime.tv_sec % 86400 == 0) { 118 xtime.tv_sec--; 119 wall_to_monotonic.tv_sec++; 120 time_state = TIME_OOP; 121 printk(KERN_NOTICE "Clock: inserting leap second " 122 "23:59:60 UTC\n"); 123 } 124 break; 125 case TIME_DEL: 126 if ((xtime.tv_sec + 1) % 86400 == 0) { 127 xtime.tv_sec++; 128 wall_to_monotonic.tv_sec--; 129 time_state = TIME_WAIT; 130 printk(KERN_NOTICE "Clock: deleting leap second " 131 "23:59:59 UTC\n"); 132 } 133 break; 134 case TIME_OOP: 135 time_state = TIME_WAIT; 136 break; 137 case TIME_WAIT: 138 if (!(time_status & (STA_INS | STA_DEL))) 139 time_state = TIME_OK; 140 } 141 142 /* 143 * Compute the phase adjustment for the next second. The offset is 144 * reduced by a fixed factor times the time constant. 145 */ 146 tick_length = tick_length_base; 147 time_adj = shift_right(time_offset, SHIFT_PLL + time_constant); 148 time_offset -= time_adj; 149 tick_length += (s64)time_adj << (TICK_LENGTH_SHIFT - SHIFT_UPDATE); 150 151 if (unlikely(time_adjust)) { 152 if (time_adjust > MAX_TICKADJ) { 153 time_adjust -= MAX_TICKADJ; 154 tick_length += MAX_TICKADJ_SCALED; 155 } else if (time_adjust < -MAX_TICKADJ) { 156 time_adjust += MAX_TICKADJ; 157 tick_length -= MAX_TICKADJ_SCALED; 158 } else { 159 tick_length += (s64)(time_adjust * NSEC_PER_USEC / 160 NTP_INTERVAL_FREQ) << TICK_LENGTH_SHIFT; 161 time_adjust = 0; 162 } 163 } 164 } 165 166 /* 167 * Return how long ticks are at the moment, that is, how much time 168 * update_wall_time_one_tick will add to xtime next time we call it 169 * (assuming no calls to do_adjtimex in the meantime). 170 * The return value is in fixed-point nanoseconds shifted by the 171 * specified number of bits to the right of the binary point. 172 * This function has no side-effects. 173 */ 174 u64 current_tick_length(void) 175 { 176 return tick_length; 177 } 178 179 #ifdef CONFIG_GENERIC_CMOS_UPDATE 180 181 /* Disable the cmos update - used by virtualization and embedded */ 182 int no_sync_cmos_clock __read_mostly; 183 184 static void sync_cmos_clock(unsigned long dummy); 185 186 static DEFINE_TIMER(sync_cmos_timer, sync_cmos_clock, 0, 0); 187 188 static void sync_cmos_clock(unsigned long dummy) 189 { 190 struct timespec now, next; 191 int fail = 1; 192 193 /* 194 * If we have an externally synchronized Linux clock, then update 195 * CMOS clock accordingly every ~11 minutes. Set_rtc_mmss() has to be 196 * called as close as possible to 500 ms before the new second starts. 197 * This code is run on a timer. If the clock is set, that timer 198 * may not expire at the correct time. Thus, we adjust... 199 */ 200 if (!ntp_synced()) 201 /* 202 * Not synced, exit, do not restart a timer (if one is 203 * running, let it run out). 204 */ 205 return; 206 207 getnstimeofday(&now); 208 if (abs(xtime.tv_nsec - (NSEC_PER_SEC / 2)) <= tick_nsec / 2) 209 fail = update_persistent_clock(now); 210 211 next.tv_nsec = (NSEC_PER_SEC / 2) - now.tv_nsec; 212 if (next.tv_nsec <= 0) 213 next.tv_nsec += NSEC_PER_SEC; 214 215 if (!fail) 216 next.tv_sec = 659; 217 else 218 next.tv_sec = 0; 219 220 if (next.tv_nsec >= NSEC_PER_SEC) { 221 next.tv_sec++; 222 next.tv_nsec -= NSEC_PER_SEC; 223 } 224 mod_timer(&sync_cmos_timer, jiffies + timespec_to_jiffies(&next)); 225 } 226 227 static void notify_cmos_timer(void) 228 { 229 if (no_sync_cmos_clock) 230 mod_timer(&sync_cmos_timer, jiffies + 1); 231 } 232 233 #else 234 static inline void notify_cmos_timer(void) { } 235 #endif 236 237 /* adjtimex mainly allows reading (and writing, if superuser) of 238 * kernel time-keeping variables. used by xntpd. 239 */ 240 int do_adjtimex(struct timex *txc) 241 { 242 long mtemp, save_adjust, rem; 243 s64 freq_adj, temp64; 244 int result; 245 246 /* In order to modify anything, you gotta be super-user! */ 247 if (txc->modes && !capable(CAP_SYS_TIME)) 248 return -EPERM; 249 250 /* Now we validate the data before disabling interrupts */ 251 252 if ((txc->modes & ADJ_OFFSET_SINGLESHOT) == ADJ_OFFSET_SINGLESHOT) 253 /* singleshot must not be used with any other mode bits */ 254 if (txc->modes != ADJ_OFFSET_SINGLESHOT) 255 return -EINVAL; 256 257 if (txc->modes != ADJ_OFFSET_SINGLESHOT && (txc->modes & ADJ_OFFSET)) 258 /* adjustment Offset limited to +- .512 seconds */ 259 if (txc->offset <= - MAXPHASE || txc->offset >= MAXPHASE ) 260 return -EINVAL; 261 262 /* if the quartz is off by more than 10% something is VERY wrong ! */ 263 if (txc->modes & ADJ_TICK) 264 if (txc->tick < 900000/USER_HZ || 265 txc->tick > 1100000/USER_HZ) 266 return -EINVAL; 267 268 write_seqlock_irq(&xtime_lock); 269 result = time_state; /* mostly `TIME_OK' */ 270 271 /* Save for later - semantics of adjtime is to return old value */ 272 save_adjust = time_adjust; 273 274 #if 0 /* STA_CLOCKERR is never set yet */ 275 time_status &= ~STA_CLOCKERR; /* reset STA_CLOCKERR */ 276 #endif 277 /* If there are input parameters, then process them */ 278 if (txc->modes) 279 { 280 if (txc->modes & ADJ_STATUS) /* only set allowed bits */ 281 time_status = (txc->status & ~STA_RONLY) | 282 (time_status & STA_RONLY); 283 284 if (txc->modes & ADJ_FREQUENCY) { /* p. 22 */ 285 if (txc->freq > MAXFREQ || txc->freq < -MAXFREQ) { 286 result = -EINVAL; 287 goto leave; 288 } 289 time_freq = ((s64)txc->freq * NSEC_PER_USEC) 290 >> (SHIFT_USEC - SHIFT_NSEC); 291 } 292 293 if (txc->modes & ADJ_MAXERROR) { 294 if (txc->maxerror < 0 || txc->maxerror >= NTP_PHASE_LIMIT) { 295 result = -EINVAL; 296 goto leave; 297 } 298 time_maxerror = txc->maxerror; 299 } 300 301 if (txc->modes & ADJ_ESTERROR) { 302 if (txc->esterror < 0 || txc->esterror >= NTP_PHASE_LIMIT) { 303 result = -EINVAL; 304 goto leave; 305 } 306 time_esterror = txc->esterror; 307 } 308 309 if (txc->modes & ADJ_TIMECONST) { /* p. 24 */ 310 if (txc->constant < 0) { /* NTP v4 uses values > 6 */ 311 result = -EINVAL; 312 goto leave; 313 } 314 time_constant = min(txc->constant + 4, (long)MAXTC); 315 } 316 317 if (txc->modes & ADJ_OFFSET) { /* values checked earlier */ 318 if (txc->modes == ADJ_OFFSET_SINGLESHOT) { 319 /* adjtime() is independent from ntp_adjtime() */ 320 time_adjust = txc->offset; 321 } 322 else if (time_status & STA_PLL) { 323 time_offset = txc->offset * NSEC_PER_USEC; 324 325 /* 326 * Scale the phase adjustment and 327 * clamp to the operating range. 328 */ 329 time_offset = min(time_offset, (s64)MAXPHASE * NSEC_PER_USEC); 330 time_offset = max(time_offset, (s64)-MAXPHASE * NSEC_PER_USEC); 331 332 /* 333 * Select whether the frequency is to be controlled 334 * and in which mode (PLL or FLL). Clamp to the operating 335 * range. Ugly multiply/divide should be replaced someday. 336 */ 337 338 if (time_status & STA_FREQHOLD || time_reftime == 0) 339 time_reftime = xtime.tv_sec; 340 mtemp = xtime.tv_sec - time_reftime; 341 time_reftime = xtime.tv_sec; 342 343 freq_adj = time_offset * mtemp; 344 freq_adj = shift_right(freq_adj, time_constant * 2 + 345 (SHIFT_PLL + 2) * 2 - SHIFT_NSEC); 346 if (mtemp >= MINSEC && (time_status & STA_FLL || mtemp > MAXSEC)) { 347 temp64 = time_offset << (SHIFT_NSEC - SHIFT_FLL); 348 if (time_offset < 0) { 349 temp64 = -temp64; 350 do_div(temp64, mtemp); 351 freq_adj -= temp64; 352 } else { 353 do_div(temp64, mtemp); 354 freq_adj += temp64; 355 } 356 } 357 freq_adj += time_freq; 358 freq_adj = min(freq_adj, (s64)MAXFREQ_NSEC); 359 time_freq = max(freq_adj, (s64)-MAXFREQ_NSEC); 360 time_offset = div_long_long_rem_signed(time_offset, 361 NTP_INTERVAL_FREQ, 362 &rem); 363 time_offset <<= SHIFT_UPDATE; 364 } /* STA_PLL */ 365 } /* txc->modes & ADJ_OFFSET */ 366 if (txc->modes & ADJ_TICK) 367 tick_usec = txc->tick; 368 369 if (txc->modes & (ADJ_TICK|ADJ_FREQUENCY|ADJ_OFFSET)) 370 ntp_update_frequency(); 371 } /* txc->modes */ 372 leave: if ((time_status & (STA_UNSYNC|STA_CLOCKERR)) != 0) 373 result = TIME_ERROR; 374 375 if ((txc->modes & ADJ_OFFSET_SINGLESHOT) == ADJ_OFFSET_SINGLESHOT) 376 txc->offset = save_adjust; 377 else 378 txc->offset = ((long)shift_right(time_offset, SHIFT_UPDATE)) * 379 NTP_INTERVAL_FREQ / 1000; 380 txc->freq = (time_freq / NSEC_PER_USEC) << 381 (SHIFT_USEC - SHIFT_NSEC); 382 txc->maxerror = time_maxerror; 383 txc->esterror = time_esterror; 384 txc->status = time_status; 385 txc->constant = time_constant; 386 txc->precision = 1; 387 txc->tolerance = MAXFREQ; 388 txc->tick = tick_usec; 389 390 /* PPS is not implemented, so these are zero */ 391 txc->ppsfreq = 0; 392 txc->jitter = 0; 393 txc->shift = 0; 394 txc->stabil = 0; 395 txc->jitcnt = 0; 396 txc->calcnt = 0; 397 txc->errcnt = 0; 398 txc->stbcnt = 0; 399 write_sequnlock_irq(&xtime_lock); 400 do_gettimeofday(&txc->time); 401 notify_cmos_timer(); 402 return(result); 403 } 404