ntp.c 10.5 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12
/*
 * linux/kernel/time/ntp.c
 *
 * NTP state machine interfaces and logic.
 *
 * This code was mainly moved from kernel/timer.c and kernel/time.c
 * Please see those files for relevant copyright info and historical
 * changelogs.
 */

#include <linux/mm.h>
#include <linux/time.h>
13
#include <linux/timer.h>
14
#include <linux/timex.h>
A
Alexey Dobriyan 已提交
15 16
#include <linux/jiffies.h>
#include <linux/hrtimer.h>
A
Alexey Dobriyan 已提交
17
#include <linux/capability.h>
R
Roman Zippel 已提交
18
#include <linux/math64.h>
19 20
#include <asm/timex.h>

21 22 23 24 25
/*
 * Timekeeping variables
 */
unsigned long tick_usec = TICK_USEC; 		/* USER_HZ period (usec) */
unsigned long tick_nsec;			/* ACTHZ period (nsec) */
R
Roman Zippel 已提交
26 27
u64 tick_length;
static u64 tick_length_base;
28

29 30
#define MAX_TICKADJ		500		/* microsecs */
#define MAX_TICKADJ_SCALED	(((u64)(MAX_TICKADJ * NSEC_PER_USEC) << \
31
				  NTP_SCALE_SHIFT) / NTP_INTERVAL_FREQ)
32 33 34 35 36

/*
 * phase-lock loop variables
 */
/* TIME_ERROR prevents overwriting the CMOS clock */
37
static int time_state = TIME_OK;	/* clock synchronization status	*/
38
int time_status = STA_UNSYNC;		/* clock status bits		*/
R
Roman Zippel 已提交
39
static long time_tai;			/* TAI offset (s)		*/
R
Roman Zippel 已提交
40
static s64 time_offset;			/* time adjustment (ns)		*/
41
static long time_constant = 2;		/* pll time constant		*/
42 43
long time_maxerror = NTP_PHASE_LIMIT;	/* maximum error (us)		*/
long time_esterror = NTP_PHASE_LIMIT;	/* estimated error (us)		*/
44
static s64 time_freq;			/* frequency offset (scaled ns/s)*/
45
static long time_reftime;		/* time at last adjustment (s)	*/
46
long time_adjust;
47
static long ntp_tick_adj;
48

49 50
static void ntp_update_frequency(void)
{
J
john stultz 已提交
51
	u64 second_length = (u64)(tick_usec * NSEC_PER_USEC * USER_HZ)
52 53
				<< NTP_SCALE_SHIFT;
	second_length += (s64)ntp_tick_adj << NTP_SCALE_SHIFT;
54
	second_length += time_freq;
55

J
john stultz 已提交
56
	tick_length_base = second_length;
57

58
	tick_nsec = div_u64(second_length, HZ) >> NTP_SCALE_SHIFT;
R
Roman Zippel 已提交
59
	tick_length_base = div_u64(tick_length_base, NTP_INTERVAL_FREQ);
60 61
}

R
Roman Zippel 已提交
62 63 64 65 66 67 68 69
static void ntp_update_offset(long offset)
{
	long mtemp;
	s64 freq_adj;

	if (!(time_status & STA_PLL))
		return;

R
Roman Zippel 已提交
70
	if (!(time_status & STA_NANO))
71
		offset *= NSEC_PER_USEC;
R
Roman Zippel 已提交
72 73 74 75 76

	/*
	 * Scale the phase adjustment and
	 * clamp to the operating range.
	 */
77 78
	offset = min(offset, MAXPHASE);
	offset = max(offset, -MAXPHASE);
R
Roman Zippel 已提交
79 80 81 82 83 84 85 86 87 88

	/*
	 * Select how the frequency is to be controlled
	 * and in which mode (PLL or FLL).
	 */
	if (time_status & STA_FREQHOLD || time_reftime == 0)
		time_reftime = xtime.tv_sec;
	mtemp = xtime.tv_sec - time_reftime;
	time_reftime = xtime.tv_sec;

89
	freq_adj = (s64)offset * mtemp;
90
	freq_adj <<= NTP_SCALE_SHIFT - 2 * (SHIFT_PLL + 2 + time_constant);
R
Roman Zippel 已提交
91 92
	time_status &= ~STA_MODE;
	if (mtemp >= MINSEC && (time_status & STA_FLL || mtemp > MAXSEC)) {
93
		freq_adj += div_s64((s64)offset << (NTP_SCALE_SHIFT - SHIFT_FLL),
94
				    mtemp);
R
Roman Zippel 已提交
95 96
		time_status |= STA_MODE;
	}
R
Roman Zippel 已提交
97
	freq_adj += time_freq;
98 99
	freq_adj = min(freq_adj, MAXFREQ_SCALED);
	time_freq = max(freq_adj, -MAXFREQ_SCALED);
100

101
	time_offset = div_s64((s64)offset << NTP_SCALE_SHIFT, NTP_INTERVAL_FREQ);
R
Roman Zippel 已提交
102 103
}

104 105 106 107 108 109 110 111 112 113 114 115 116 117 118
/**
 * ntp_clear - Clears the NTP state variables
 *
 * Must be called while holding a write on the xtime_lock
 */
void ntp_clear(void)
{
	time_adjust = 0;		/* stop active adjtime() */
	time_status |= STA_UNSYNC;
	time_maxerror = NTP_PHASE_LIMIT;
	time_esterror = NTP_PHASE_LIMIT;

	ntp_update_frequency();

	tick_length = tick_length_base;
R
Roman Zippel 已提交
119
	time_offset = 0;
120 121
}

122 123 124 125 126 127 128 129 130 131
/*
 * this routine handles the overflow of the microsecond field
 *
 * The tricky bits of code to handle the accurate clock support
 * were provided by Dave Mills (Mills@UDEL.EDU) of NTP fame.
 * They were originally developed for SUN and DEC kernels.
 * All the kudos should go to Dave for this stuff.
 */
void second_overflow(void)
{
132
	s64 time_adj;
133 134

	/* Bump the maxerror field */
135
	time_maxerror += MAXFREQ / NSEC_PER_USEC;
136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166
	if (time_maxerror > NTP_PHASE_LIMIT) {
		time_maxerror = NTP_PHASE_LIMIT;
		time_status |= STA_UNSYNC;
	}

	/*
	 * Leap second processing. If in leap-insert state at the end of the
	 * day, the system clock is set back one second; if in leap-delete
	 * state, the system clock is set ahead one second. The microtime()
	 * routine or external clock driver will insure that reported time is
	 * always monotonic. The ugly divides should be replaced.
	 */
	switch (time_state) {
	case TIME_OK:
		if (time_status & STA_INS)
			time_state = TIME_INS;
		else if (time_status & STA_DEL)
			time_state = TIME_DEL;
		break;
	case TIME_INS:
		if (xtime.tv_sec % 86400 == 0) {
			xtime.tv_sec--;
			wall_to_monotonic.tv_sec++;
			time_state = TIME_OOP;
			printk(KERN_NOTICE "Clock: inserting leap second "
					"23:59:60 UTC\n");
		}
		break;
	case TIME_DEL:
		if ((xtime.tv_sec + 1) % 86400 == 0) {
			xtime.tv_sec++;
R
Roman Zippel 已提交
167
			time_tai--;
168 169 170 171 172 173 174
			wall_to_monotonic.tv_sec--;
			time_state = TIME_WAIT;
			printk(KERN_NOTICE "Clock: deleting leap second "
					"23:59:59 UTC\n");
		}
		break;
	case TIME_OOP:
R
Roman Zippel 已提交
175
		time_tai++;
176 177 178 179
		time_state = TIME_WAIT;
		break;
	case TIME_WAIT:
		if (!(time_status & (STA_INS | STA_DEL)))
R
Roman Zippel 已提交
180
			time_state = TIME_OK;
181 182 183
	}

	/*
184 185
	 * Compute the phase adjustment for the next second. The offset is
	 * reduced by a fixed factor times the time constant.
186
	 */
187
	tick_length = tick_length_base;
188
	time_adj = shift_right(time_offset, SHIFT_PLL + time_constant);
R
Roman Zippel 已提交
189
	time_offset -= time_adj;
190
	tick_length += time_adj;
191

192 193 194 195 196 197 198 199 200
	if (unlikely(time_adjust)) {
		if (time_adjust > MAX_TICKADJ) {
			time_adjust -= MAX_TICKADJ;
			tick_length += MAX_TICKADJ_SCALED;
		} else if (time_adjust < -MAX_TICKADJ) {
			time_adjust += MAX_TICKADJ;
			tick_length -= MAX_TICKADJ_SCALED;
		} else {
			tick_length += (s64)(time_adjust * NSEC_PER_USEC /
201
					NTP_INTERVAL_FREQ) << NTP_SCALE_SHIFT;
202
			time_adjust = 0;
203
		}
204 205 206
	}
}

207
#ifdef CONFIG_GENERIC_CMOS_UPDATE
208

209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235
/* Disable the cmos update - used by virtualization and embedded */
int no_sync_cmos_clock  __read_mostly;

static void sync_cmos_clock(unsigned long dummy);

static DEFINE_TIMER(sync_cmos_timer, sync_cmos_clock, 0, 0);

static void sync_cmos_clock(unsigned long dummy)
{
	struct timespec now, next;
	int fail = 1;

	/*
	 * If we have an externally synchronized Linux clock, then update
	 * CMOS clock accordingly every ~11 minutes. Set_rtc_mmss() has to be
	 * called as close as possible to 500 ms before the new second starts.
	 * This code is run on a timer.  If the clock is set, that timer
	 * may not expire at the correct time.  Thus, we adjust...
	 */
	if (!ntp_synced())
		/*
		 * Not synced, exit, do not restart a timer (if one is
		 * running, let it run out).
		 */
		return;

	getnstimeofday(&now);
236
	if (abs(now.tv_nsec - (NSEC_PER_SEC / 2)) <= tick_nsec / 2)
237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255
		fail = update_persistent_clock(now);

	next.tv_nsec = (NSEC_PER_SEC / 2) - now.tv_nsec;
	if (next.tv_nsec <= 0)
		next.tv_nsec += NSEC_PER_SEC;

	if (!fail)
		next.tv_sec = 659;
	else
		next.tv_sec = 0;

	if (next.tv_nsec >= NSEC_PER_SEC) {
		next.tv_sec++;
		next.tv_nsec -= NSEC_PER_SEC;
	}
	mod_timer(&sync_cmos_timer, jiffies + timespec_to_jiffies(&next));
}

static void notify_cmos_timer(void)
256
{
257
	if (!no_sync_cmos_clock)
258
		mod_timer(&sync_cmos_timer, jiffies + 1);
259 260
}

261 262 263 264
#else
static inline void notify_cmos_timer(void) { }
#endif

265 266 267 268 269
/* adjtimex mainly allows reading (and writing, if superuser) of
 * kernel time-keeping variables. used by xntpd.
 */
int do_adjtimex(struct timex *txc)
{
R
Roman Zippel 已提交
270
	struct timespec ts;
R
Roman Zippel 已提交
271
	long save_adjust;
272 273 274 275 276 277 278 279
	int result;

	/* In order to modify anything, you gotta be super-user! */
	if (txc->modes && !capable(CAP_SYS_TIME))
		return -EPERM;

	/* Now we validate the data before disabling interrupts */

J
John Stultz 已提交
280
	if ((txc->modes & ADJ_OFFSET_SINGLESHOT) == ADJ_OFFSET_SINGLESHOT) {
R
Roman Zippel 已提交
281 282
		/* singleshot must not be used with any other mode bits */
		if (txc->modes & ~ADJ_OFFSET_SS_READ)
283
			return -EINVAL;
J
John Stultz 已提交
284
	}
285 286 287 288 289 290 291 292 293 294

	/* if the quartz is off by more than 10% something is VERY wrong ! */
	if (txc->modes & ADJ_TICK)
		if (txc->tick <  900000/USER_HZ ||
		    txc->tick > 1100000/USER_HZ)
			return -EINVAL;

	write_seqlock_irq(&xtime_lock);

	/* Save for later - semantics of adjtime is to return old value */
295
	save_adjust = time_adjust;
296 297

	/* If there are input parameters, then process them */
R
Roman Zippel 已提交
298
	if (txc->modes) {
R
Roman Zippel 已提交
299 300 301 302 303 304 305 306 307 308 309 310 311 312 313
		if (txc->modes & ADJ_STATUS) {
			if ((time_status & STA_PLL) &&
			    !(txc->status & STA_PLL)) {
				time_state = TIME_OK;
				time_status = STA_UNSYNC;
			}
			/* only set allowed bits */
			time_status &= STA_RONLY;
			time_status |= txc->status & ~STA_RONLY;
		}

		if (txc->modes & ADJ_NANO)
			time_status |= STA_NANO;
		if (txc->modes & ADJ_MICRO)
			time_status &= ~STA_NANO;
R
Roman Zippel 已提交
314 315

		if (txc->modes & ADJ_FREQUENCY) {
316 317 318
			time_freq = (s64)txc->freq * PPM_SCALE;
			time_freq = min(time_freq, MAXFREQ_SCALED);
			time_freq = max(time_freq, -MAXFREQ_SCALED);
319
		}
R
Roman Zippel 已提交
320

R
Roman Zippel 已提交
321
		if (txc->modes & ADJ_MAXERROR)
R
Roman Zippel 已提交
322
			time_maxerror = txc->maxerror;
R
Roman Zippel 已提交
323
		if (txc->modes & ADJ_ESTERROR)
R
Roman Zippel 已提交
324
			time_esterror = txc->esterror;
325

R
Roman Zippel 已提交
326
		if (txc->modes & ADJ_TIMECONST) {
R
Roman Zippel 已提交
327 328 329 330 331
			time_constant = txc->constant;
			if (!(time_status & STA_NANO))
				time_constant += 4;
			time_constant = min(time_constant, (long)MAXTC);
			time_constant = max(time_constant, 0l);
332 333
		}

R
Roman Zippel 已提交
334 335 336
		if (txc->modes & ADJ_TAI && txc->constant > 0)
			time_tai = txc->constant;

R
Roman Zippel 已提交
337 338 339 340 341 342
		if (txc->modes & ADJ_OFFSET) {
			if (txc->modes == ADJ_OFFSET_SINGLESHOT)
				/* adjtime() is independent from ntp_adjtime() */
				time_adjust = txc->offset;
			else
				ntp_update_offset(txc->offset);
343
		}
R
Roman Zippel 已提交
344 345 346 347 348 349
		if (txc->modes & ADJ_TICK)
			tick_usec = txc->tick;

		if (txc->modes & (ADJ_TICK|ADJ_FREQUENCY|ADJ_OFFSET))
			ntp_update_frequency();
	}
R
Roman Zippel 已提交
350 351

	result = time_state;	/* mostly `TIME_OK' */
R
Roman Zippel 已提交
352
	if (time_status & (STA_UNSYNC|STA_CLOCKERR))
353 354
		result = TIME_ERROR;

J
John Stultz 已提交
355
	if ((txc->modes == ADJ_OFFSET_SINGLESHOT) ||
R
Roman Zippel 已提交
356
	    (txc->modes == ADJ_OFFSET_SS_READ))
357
		txc->offset = save_adjust;
R
Roman Zippel 已提交
358
	else {
359
		txc->offset = shift_right(time_offset * NTP_INTERVAL_FREQ,
360
					  NTP_SCALE_SHIFT);
R
Roman Zippel 已提交
361 362 363
		if (!(time_status & STA_NANO))
			txc->offset /= NSEC_PER_USEC;
	}
364 365
	txc->freq	   = shift_right((s32)(time_freq >> PPM_SCALE_INV_SHIFT) *
					 (s64)PPM_SCALE_INV,
366
					 NTP_SCALE_SHIFT);
367 368 369 370
	txc->maxerror	   = time_maxerror;
	txc->esterror	   = time_esterror;
	txc->status	   = time_status;
	txc->constant	   = time_constant;
371
	txc->precision	   = 1;
372
	txc->tolerance	   = MAXFREQ_SCALED / PPM_SCALE;
373
	txc->tick	   = tick_usec;
R
Roman Zippel 已提交
374
	txc->tai	   = time_tai;
375 376 377 378 379 380 381 382 383 384 385

	/* PPS is not implemented, so these are zero */
	txc->ppsfreq	   = 0;
	txc->jitter	   = 0;
	txc->shift	   = 0;
	txc->stabil	   = 0;
	txc->jitcnt	   = 0;
	txc->calcnt	   = 0;
	txc->errcnt	   = 0;
	txc->stbcnt	   = 0;
	write_sequnlock_irq(&xtime_lock);
R
Roman Zippel 已提交
386

R
Roman Zippel 已提交
387 388 389 390 391
	getnstimeofday(&ts);
	txc->time.tv_sec = ts.tv_sec;
	txc->time.tv_usec = ts.tv_nsec;
	if (!(time_status & STA_NANO))
		txc->time.tv_usec /= NSEC_PER_USEC;
R
Roman Zippel 已提交
392

393
	notify_cmos_timer();
R
Roman Zippel 已提交
394 395

	return result;
396
}
397 398 399 400 401 402 403 404

static int __init ntp_tick_adj_setup(char *str)
{
	ntp_tick_adj = simple_strtol(str, NULL, 0);
	return 1;
}

__setup("ntp_tick_adj=", ntp_tick_adj_setup);