[RFC PATCH v2] timekeeper latch synchronization

[RFC PATCH v2] timekeeper latch synchronization

[Mathieu Desnoyers]

Hi,

Here is my timekeeper latch synchronization series update, still as RFC.
It now passes the timetests provided by John Stultz
(https://github.com/johnstultz-work/timetests.git). See the changelog of
"Introduce timekeeper latch synchronization" to get a clear picture of
all the goodness introduced by this scheme. ;-)

Comments are welcome,

Thanks!

Mathieu

[PATCH 1/7] Move ntp variables into struct timekeeper_ntp

[Mathieu Desnoyers]

Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Cc: John Stultz <john.stultz@linaro.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Peter Zijlstra <peterz@infradead.org>
---
 include/linux/timekeeper_internal.h |   47 ++++++
 kernel/time/ntp.c                   |  318 +++++++++++++++--------------------
 2 files changed, 187 insertions(+), 178 deletions(-)

diff --git a/include/linux/timekeeper_internal.h b/include/linux/timekeeper_internal.h
index c1825eb..eab26e0 100644
--- a/include/linux/timekeeper_internal.h
+++ b/include/linux/timekeeper_internal.h
@@ -10,6 +10,53 @@
 #include <linux/jiffies.h>
 #include <linux/time.h>
 
+/* structure holding internal NTP timekeeping values. */
+struct timekeeper_ntp {
+	/* USER_HZ period (usecs): */
+	unsigned long		tick_usec;
+
+	/* SHIFTED_HZ period (nsecs): */
+	unsigned long		tick_nsec;
+
+	u64			tick_length;
+	u64			tick_length_base;
+
+	/* phase-lock loop variables */
+
+	/*
+	 * clock synchronization status
+	 *
+	 * (TIME_ERROR prevents overwriting the CMOS clock)
+	 */
+	int			time_state;
+
+	/* clock status bits: */
+	int			time_status;
+
+	/* time adjustment (nsecs): */
+	s64			time_offset;
+
+	/* pll time constant: */
+	long			time_constant;
+
+	/* maximum error (usecs): */
+	long			time_maxerror;
+
+	/* estimated error (usecs): */
+	long			time_esterror;
+
+	/* frequency offset (scaled nsecs/secs): */
+	s64			time_freq;
+
+	/* time at last adjustment (secs): */
+	long			time_reftime;
+
+	long			time_adjust;
+
+	/* constant (boot-param configurable) NTP tick adjustment (upscaled) */
+	s64			ntp_tick_adj;
+};
+
 /* Structure holding internal timekeeping values. */
 struct timekeeper {
 	/* Current clocksource used for timekeeping. */
diff --git a/kernel/time/ntp.c b/kernel/time/ntp.c
index bb22151..983c212 100644
--- a/kernel/time/ntp.c
+++ b/kernel/time/ntp.c
@@ -16,66 +16,23 @@
 #include <linux/mm.h>
 #include <linux/module.h>
 #include <linux/rtc.h>
+#include <linux/timekeeper_internal.h>
 
 #include "tick-internal.h"
 #include "ntp_internal.h"
 
-/*
- * NTP timekeeping variables:
- *
- * Note: All of the NTP state is protected by the timekeeping locks.
- */
-
-
-/* USER_HZ period (usecs): */
-unsigned long			tick_usec = TICK_USEC;
-
-/* SHIFTED_HZ period (nsecs): */
-unsigned long			tick_nsec;
-
-static u64			tick_length;
-static u64			tick_length_base;
-
 #define MAX_TICKADJ		500LL		/* usecs */
 #define MAX_TICKADJ_SCALED \
 	(((MAX_TICKADJ * NSEC_PER_USEC) << NTP_SCALE_SHIFT) / NTP_INTERVAL_FREQ)
 
-/*
- * phase-lock loop variables
- */
-
-/*
- * clock synchronization status
- *
- * (TIME_ERROR prevents overwriting the CMOS clock)
- */
-static int			time_state = TIME_OK;
-
-/* clock status bits:							*/
-static int			time_status = STA_UNSYNC;
-
-/* time adjustment (nsecs):						*/
-static s64			time_offset;
-
-/* pll time constant:							*/
-static long			time_constant = 2;
-
-/* maximum error (usecs):						*/
-static long			time_maxerror = NTP_PHASE_LIMIT;
-
-/* estimated error (usecs):						*/
-static long			time_esterror = NTP_PHASE_LIMIT;
-
-/* frequency offset (scaled nsecs/secs):				*/
-static s64			time_freq;
-
-/* time at last adjustment (secs):					*/
-static long			time_reftime;
-
-static long			time_adjust;
-
-/* constant (boot-param configurable) NTP tick adjustment (upscaled)	*/
-static s64			ntp_tick_adj;
+static struct timekeeper_ntp tk_ntp = {
+	.tick_usec = TICK_USEC,
+	.time_state = TIME_OK,
+	.time_status = STA_UNSYNC,
+	.time_constant = 2,
+	.time_maxerror = NTP_PHASE_LIMIT,
+	.time_esterror = NTP_PHASE_LIMIT,
+};
 
 #ifdef CONFIG_NTP_PPS
 
@@ -116,10 +73,11 @@ static long pps_errcnt;		/* calibration errors */
  */
 static inline s64 ntp_offset_chunk(s64 offset)
 {
-	if (time_status & STA_PPSTIME && time_status & STA_PPSSIGNAL)
+	if (tk_ntp.time_status & STA_PPSTIME
+			&& tk_ntp.time_status & STA_PPSSIGNAL)
 		return offset;
 	else
-		return shift_right(offset, SHIFT_PLL + time_constant);
+		return shift_right(offset, SHIFT_PLL + tk_ntp.time_constant);
 }
 
 static inline void pps_reset_freq_interval(void)
@@ -152,7 +110,7 @@ static inline void pps_dec_valid(void)
 	if (pps_valid > 0)
 		pps_valid--;
 	else {
-		time_status &= ~(STA_PPSSIGNAL | STA_PPSJITTER |
+		tk_ntp.time_status &= ~(STA_PPSSIGNAL | STA_PPSJITTER |
 				 STA_PPSWANDER | STA_PPSERROR);
 		pps_clear();
 	}
@@ -165,21 +123,21 @@ static inline void pps_set_freq(s64 freq)
 
 static inline int is_error_status(int status)
 {
-	return (time_status & (STA_UNSYNC|STA_CLOCKERR))
+	return (tk_ntp.time_status & (STA_UNSYNC|STA_CLOCKERR))
 		/* PPS signal lost when either PPS time or
 		 * PPS frequency synchronization requested
 		 */
-		|| ((time_status & (STA_PPSFREQ|STA_PPSTIME))
-			&& !(time_status & STA_PPSSIGNAL))
+		|| ((tk_ntp.time_status & (STA_PPSFREQ|STA_PPSTIME))
+			&& !(tk_ntp.time_status & STA_PPSSIGNAL))
 		/* PPS jitter exceeded when
 		 * PPS time synchronization requested */
-		|| ((time_status & (STA_PPSTIME|STA_PPSJITTER))
+		|| ((tk_ntp.time_status & (STA_PPSTIME|STA_PPSJITTER))
 			== (STA_PPSTIME|STA_PPSJITTER))
 		/* PPS wander exceeded or calibration error when
 		 * PPS frequency synchronization requested
 		 */
-		|| ((time_status & STA_PPSFREQ)
-			&& (time_status & (STA_PPSWANDER|STA_PPSERROR)));
+		|| ((tk_ntp.time_status & STA_PPSFREQ)
+			&& (tk_ntp.time_status & (STA_PPSWANDER|STA_PPSERROR)));
 }
 
 static inline void pps_fill_timex(struct timex *txc)
@@ -187,7 +145,7 @@ static inline void pps_fill_timex(struct timex *txc)
 	txc->ppsfreq	   = shift_right((pps_freq >> PPM_SCALE_INV_SHIFT) *
 					 PPM_SCALE_INV, NTP_SCALE_SHIFT);
 	txc->jitter	   = pps_jitter;
-	if (!(time_status & STA_NANO))
+	if (!(tk_ntp.time_status & STA_NANO))
 		txc->jitter /= NSEC_PER_USEC;
 	txc->shift	   = pps_shift;
 	txc->stabil	   = pps_stabil;
@@ -201,7 +159,7 @@ static inline void pps_fill_timex(struct timex *txc)
 
 static inline s64 ntp_offset_chunk(s64 offset)
 {
-	return shift_right(offset, SHIFT_PLL + time_constant);
+	return shift_right(offset, SHIFT_PLL + tk_ntp.time_constant);
 }
 
 static inline void pps_reset_freq_interval(void) {}
@@ -236,7 +194,7 @@ static inline void pps_fill_timex(struct timex *txc)
  */
 static inline int ntp_synced(void)
 {
-	return !(time_status & STA_UNSYNC);
+	return !(tk_ntp.time_status & STA_UNSYNC);
 }
 
 
@@ -245,42 +203,42 @@ static inline int ntp_synced(void)
  */
 
 /*
- * Update (tick_length, tick_length_base, tick_nsec), based
- * on (tick_usec, ntp_tick_adj, time_freq):
+ * Update (tk_ntp.tick_length, tk_ntp.tick_length_base, tk_ntp.tick_nsec),
+ * based on (tk_ntp.tick_usec, tk_ntp.ntp_tick_adj, tk_ntp.time_freq):
  */
 static void ntp_update_frequency(void)
 {
 	u64 second_length;
 	u64 new_base;
 
-	second_length		 = (u64)(tick_usec * NSEC_PER_USEC * USER_HZ)
+	second_length = (u64)(tk_ntp.tick_usec * NSEC_PER_USEC * USER_HZ)
 						<< NTP_SCALE_SHIFT;
 
-	second_length		+= ntp_tick_adj;
-	second_length		+= time_freq;
+	second_length += tk_ntp.ntp_tick_adj;
+	second_length += tk_ntp.time_freq;
 
-	tick_nsec		 = div_u64(second_length, HZ) >> NTP_SCALE_SHIFT;
-	new_base		 = div_u64(second_length, NTP_INTERVAL_FREQ);
+	tk_ntp.tick_nsec = div_u64(second_length, HZ) >> NTP_SCALE_SHIFT;
+	new_base = div_u64(second_length, NTP_INTERVAL_FREQ);
 
 	/*
 	 * Don't wait for the next second_overflow, apply
 	 * the change to the tick length immediately:
 	 */
-	tick_length		+= new_base - tick_length_base;
-	tick_length_base	 = new_base;
+	tk_ntp.tick_length += new_base - tk_ntp.tick_length_base;
+	tk_ntp.tick_length_base = new_base;
 }
 
 static inline s64 ntp_update_offset_fll(s64 offset64, long secs)
 {
-	time_status &= ~STA_MODE;
+	tk_ntp.time_status &= ~STA_MODE;
 
 	if (secs < MINSEC)
 		return 0;
 
-	if (!(time_status & STA_FLL) && (secs <= MAXSEC))
+	if (!(tk_ntp.time_status & STA_FLL) && (secs <= MAXSEC))
 		return 0;
 
-	time_status |= STA_MODE;
+	tk_ntp.time_status |= STA_MODE;
 
 	return div64_long(offset64 << (NTP_SCALE_SHIFT - SHIFT_FLL), secs);
 }
@@ -291,10 +249,10 @@ static void ntp_update_offset(long offset)
 	s64 offset64;
 	long secs;
 
-	if (!(time_status & STA_PLL))
+	if (!(tk_ntp.time_status & STA_PLL))
 		return;
 
-	if (!(time_status & STA_NANO))
+	if (!(tk_ntp.time_status & STA_NANO))
 		offset *= NSEC_PER_USEC;
 
 	/*
@@ -308,11 +266,11 @@ static void ntp_update_offset(long offset)
 	 * Select how the frequency is to be controlled
 	 * and in which mode (PLL or FLL).
 	 */
-	secs = get_seconds() - time_reftime;
-	if (unlikely(time_status & STA_FREQHOLD))
+	secs = get_seconds() - tk_ntp.time_reftime;
+	if (unlikely(tk_ntp.time_status & STA_FREQHOLD))
 		secs = 0;
 
-	time_reftime = get_seconds();
+	tk_ntp.time_reftime = get_seconds();
 
 	offset64    = offset;
 	freq_adj    = ntp_update_offset_fll(offset64, secs);
@@ -322,17 +280,18 @@ static void ntp_update_offset(long offset)
 	 * sampling rate (e.g. intermittent network connection)
 	 * to avoid instability.
 	 */
-	if (unlikely(secs > 1 << (SHIFT_PLL + 1 + time_constant)))
-		secs = 1 << (SHIFT_PLL + 1 + time_constant);
+	if (unlikely(secs > 1 << (SHIFT_PLL + 1 + tk_ntp.time_constant)))
+		secs = 1 << (SHIFT_PLL + 1 + tk_ntp.time_constant);
 
 	freq_adj    += (offset64 * secs) <<
-			(NTP_SCALE_SHIFT - 2 * (SHIFT_PLL + 2 + time_constant));
+		(NTP_SCALE_SHIFT - 2 * (SHIFT_PLL + 2 + tk_ntp.time_constant));
 
-	freq_adj    = min(freq_adj + time_freq, MAXFREQ_SCALED);
+	freq_adj    = min(freq_adj + tk_ntp.time_freq, MAXFREQ_SCALED);
 
-	time_freq   = max(freq_adj, -MAXFREQ_SCALED);
+	tk_ntp.time_freq   = max(freq_adj, -MAXFREQ_SCALED);
 
-	time_offset = div_s64(offset64 << NTP_SCALE_SHIFT, NTP_INTERVAL_FREQ);
+	tk_ntp.time_offset = div_s64(offset64 << NTP_SCALE_SHIFT,
+		NTP_INTERVAL_FREQ);
 }
 
 /**
@@ -340,15 +299,15 @@ static void ntp_update_offset(long offset)
  */
 void ntp_clear(void)
 {
-	time_adjust	= 0;		/* stop active adjtime() */
-	time_status	|= STA_UNSYNC;
-	time_maxerror	= NTP_PHASE_LIMIT;
-	time_esterror	= NTP_PHASE_LIMIT;
+	tk_ntp.time_adjust	= 0;		/* stop active adjtime() */
+	tk_ntp.time_status	|= STA_UNSYNC;
+	tk_ntp.time_maxerror	= NTP_PHASE_LIMIT;
+	tk_ntp.time_esterror	= NTP_PHASE_LIMIT;
 
 	ntp_update_frequency();
 
-	tick_length	= tick_length_base;
-	time_offset	= 0;
+	tk_ntp.tick_length	= tk_ntp.tick_length_base;
+	tk_ntp.time_offset	= 0;
 
 	/* Clear PPS state variables */
 	pps_clear();
@@ -357,7 +316,7 @@ void ntp_clear(void)
 
 u64 ntp_tick_length(void)
 {
-	return tick_length;
+	return tk_ntp.tick_length;
 }
 
 
@@ -381,79 +340,80 @@ int second_overflow(unsigned long secs)
 	 * day, the system clock is set back one second; if in leap-delete
 	 * state, the system clock is set ahead one second.
 	 */
-	switch (time_state) {
+	switch (tk_ntp.time_state) {
 	case TIME_OK:
-		if (time_status & STA_INS)
-			time_state = TIME_INS;
-		else if (time_status & STA_DEL)
-			time_state = TIME_DEL;
+		if (tk_ntp.time_status & STA_INS)
+			tk_ntp.time_state = TIME_INS;
+		else if (tk_ntp.time_status & STA_DEL)
+			tk_ntp.time_state = TIME_DEL;
 		break;
 	case TIME_INS:
-		if (!(time_status & STA_INS))
-			time_state = TIME_OK;
+		if (!(tk_ntp.time_status & STA_INS))
+			tk_ntp.time_state = TIME_OK;
 		else if (secs % 86400 == 0) {
 			leap = -1;
-			time_state = TIME_OOP;
+			tk_ntp.time_state = TIME_OOP;
 			printk(KERN_NOTICE
 				"Clock: inserting leap second 23:59:60 UTC\n");
 		}
 		break;
 	case TIME_DEL:
-		if (!(time_status & STA_DEL))
-			time_state = TIME_OK;
+		if (!(tk_ntp.time_status & STA_DEL))
+			tk_ntp.time_state = TIME_OK;
 		else if ((secs + 1) % 86400 == 0) {
 			leap = 1;
-			time_state = TIME_WAIT;
+			tk_ntp.time_state = TIME_WAIT;
 			printk(KERN_NOTICE
 				"Clock: deleting leap second 23:59:59 UTC\n");
 		}
 		break;
 	case TIME_OOP:
-		time_state = TIME_WAIT;
+		tk_ntp.time_state = TIME_WAIT;
 		break;
 
 	case TIME_WAIT:
-		if (!(time_status & (STA_INS | STA_DEL)))
-			time_state = TIME_OK;
+		if (!(tk_ntp.time_status & (STA_INS | STA_DEL)))
+			tk_ntp.time_state = TIME_OK;
 		break;
 	}
 
 
 	/* Bump the maxerror field */
-	time_maxerror += MAXFREQ / NSEC_PER_USEC;
-	if (time_maxerror > NTP_PHASE_LIMIT) {
-		time_maxerror = NTP_PHASE_LIMIT;
-		time_status |= STA_UNSYNC;
+	tk_ntp.time_maxerror += MAXFREQ / NSEC_PER_USEC;
+	if (tk_ntp.time_maxerror > NTP_PHASE_LIMIT) {
+		tk_ntp.time_maxerror = NTP_PHASE_LIMIT;
+		tk_ntp.time_status |= STA_UNSYNC;
 	}
 
 	/* Compute the phase adjustment for the next second */
-	tick_length	 = tick_length_base;
+	tk_ntp.tick_length = tk_ntp.tick_length_base;
 
-	delta		 = ntp_offset_chunk(time_offset);
-	time_offset	-= delta;
-	tick_length	+= delta;
+	delta = ntp_offset_chunk(tk_ntp.time_offset);
+	tk_ntp.time_offset -= delta;
+	tk_ntp.tick_length += delta;
 
 	/* Check PPS signal */
 	pps_dec_valid();
 
-	if (!time_adjust)
+	if (!tk_ntp.time_adjust)
 		goto out;
 
-	if (time_adjust > MAX_TICKADJ) {
-		time_adjust -= MAX_TICKADJ;
-		tick_length += MAX_TICKADJ_SCALED;
+	if (tk_ntp.time_adjust > MAX_TICKADJ) {
+		tk_ntp.time_adjust -= MAX_TICKADJ;
+		tk_ntp.tick_length += MAX_TICKADJ_SCALED;
 		goto out;
 	}
 
-	if (time_adjust < -MAX_TICKADJ) {
-		time_adjust += MAX_TICKADJ;
-		tick_length -= MAX_TICKADJ_SCALED;
+	if (tk_ntp.time_adjust < -MAX_TICKADJ) {
+		tk_ntp.time_adjust += MAX_TICKADJ;
+		tk_ntp.tick_length -= MAX_TICKADJ_SCALED;
 		goto out;
 	}
 
-	tick_length += (s64)(time_adjust * NSEC_PER_USEC / NTP_INTERVAL_FREQ)
+	tk_ntp.tick_length +=
+		(s64)(tk_ntp.time_adjust * NSEC_PER_USEC / NTP_INTERVAL_FREQ)
 							 << NTP_SCALE_SHIFT;
-	time_adjust = 0;
+	tk_ntp.time_adjust = 0;
 
 out:
 	return leap;
@@ -485,7 +445,7 @@ static void sync_cmos_clock(struct work_struct *work)
 	}
 
 	getnstimeofday(&now);
-	if (abs(now.tv_nsec - (NSEC_PER_SEC / 2)) <= tick_nsec / 2) {
+	if (abs(now.tv_nsec - (NSEC_PER_SEC / 2)) <= tk_ntp.tick_nsec / 2) {
 		struct timespec adjust = now;
 
 		fail = -ENODEV;
@@ -531,9 +491,9 @@ void ntp_notify_cmos_timer(void) { }
  */
 static inline void process_adj_status(struct timex *txc, struct timespec *ts)
 {
-	if ((time_status & STA_PLL) && !(txc->status & STA_PLL)) {
-		time_state = TIME_OK;
-		time_status = STA_UNSYNC;
+	if ((tk_ntp.time_status & STA_PLL) && !(txc->status & STA_PLL)) {
+		tk_ntp.time_state = TIME_OK;
+		tk_ntp.time_status = STA_UNSYNC;
 		/* restart PPS frequency calibration */
 		pps_reset_freq_interval();
 	}
@@ -542,12 +502,12 @@ static inline void process_adj_status(struct timex *txc, struct timespec *ts)
 	 * If we turn on PLL adjustments then reset the
 	 * reference time to current time.
 	 */
-	if (!(time_status & STA_PLL) && (txc->status & STA_PLL))
-		time_reftime = get_seconds();
+	if (!(tk_ntp.time_status & STA_PLL) && (txc->status & STA_PLL))
+		tk_ntp.time_reftime = get_seconds();
 
 	/* only set allowed bits */
-	time_status &= STA_RONLY;
-	time_status |= txc->status & ~STA_RONLY;
+	tk_ntp.time_status &= STA_RONLY;
+	tk_ntp.time_status |= txc->status & ~STA_RONLY;
 }
 
 
@@ -559,31 +519,31 @@ static inline void process_adjtimex_modes(struct timex *txc,
 		process_adj_status(txc, ts);
 
 	if (txc->modes & ADJ_NANO)
-		time_status |= STA_NANO;
+		tk_ntp.time_status |= STA_NANO;
 
 	if (txc->modes & ADJ_MICRO)
-		time_status &= ~STA_NANO;
+		tk_ntp.time_status &= ~STA_NANO;
 
 	if (txc->modes & ADJ_FREQUENCY) {
-		time_freq = txc->freq * PPM_SCALE;
-		time_freq = min(time_freq, MAXFREQ_SCALED);
-		time_freq = max(time_freq, -MAXFREQ_SCALED);
+		tk_ntp.time_freq = txc->freq * PPM_SCALE;
+		tk_ntp.time_freq = min(tk_ntp.time_freq, MAXFREQ_SCALED);
+		tk_ntp.time_freq = max(tk_ntp.time_freq, -MAXFREQ_SCALED);
 		/* update pps_freq */
-		pps_set_freq(time_freq);
+		pps_set_freq(tk_ntp.time_freq);
 	}
 
 	if (txc->modes & ADJ_MAXERROR)
-		time_maxerror = txc->maxerror;
+		tk_ntp.time_maxerror = txc->maxerror;
 
 	if (txc->modes & ADJ_ESTERROR)
-		time_esterror = txc->esterror;
+		tk_ntp.time_esterror = txc->esterror;
 
 	if (txc->modes & ADJ_TIMECONST) {
-		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);
+		tk_ntp.time_constant = txc->constant;
+		if (!(tk_ntp.time_status & STA_NANO))
+			tk_ntp.time_constant += 4;
+		tk_ntp.time_constant = min(tk_ntp.time_constant, (long)MAXTC);
+		tk_ntp.time_constant = max(tk_ntp.time_constant, 0l);
 	}
 
 	if (txc->modes & ADJ_TAI && txc->constant > 0)
@@ -593,7 +553,7 @@ static inline void process_adjtimex_modes(struct timex *txc,
 		ntp_update_offset(txc->offset);
 
 	if (txc->modes & ADJ_TICK)
-		tick_usec = txc->tick;
+		tk_ntp.tick_usec = txc->tick;
 
 	if (txc->modes & (ADJ_TICK|ADJ_FREQUENCY|ADJ_OFFSET))
 		ntp_update_frequency();
@@ -643,11 +603,11 @@ int __do_adjtimex(struct timex *txc, struct timespec *ts, s32 *time_tai)
 	int result;
 
 	if (txc->modes & ADJ_ADJTIME) {
-		long save_adjust = time_adjust;
+		long save_adjust = tk_ntp.time_adjust;
 
 		if (!(txc->modes & ADJ_OFFSET_READONLY)) {
 			/* adjtime() is independent from ntp_adjtime() */
-			time_adjust = txc->offset;
+			tk_ntp.time_adjust = txc->offset;
 			ntp_update_frequency();
 		}
 		txc->offset = save_adjust;
@@ -657,34 +617,35 @@ int __do_adjtimex(struct timex *txc, struct timespec *ts, s32 *time_tai)
 		if (txc->modes)
 			process_adjtimex_modes(txc, ts, time_tai);
 
-		txc->offset = shift_right(time_offset * NTP_INTERVAL_FREQ,
+		txc->offset =
+			shift_right(tk_ntp.time_offset * NTP_INTERVAL_FREQ,
 				  NTP_SCALE_SHIFT);
-		if (!(time_status & STA_NANO))
+		if (!(tk_ntp.time_status & STA_NANO))
 			txc->offset /= NSEC_PER_USEC;
 	}
 
-	result = time_state;	/* mostly `TIME_OK' */
+	result = tk_ntp.time_state;	/* mostly `TIME_OK' */
 	/* check for errors */
-	if (is_error_status(time_status))
+	if (is_error_status(tk_ntp.time_status))
 		result = TIME_ERROR;
 
-	txc->freq	   = shift_right((time_freq >> PPM_SCALE_INV_SHIFT) *
-					 PPM_SCALE_INV, NTP_SCALE_SHIFT);
-	txc->maxerror	   = time_maxerror;
-	txc->esterror	   = time_esterror;
-	txc->status	   = time_status;
-	txc->constant	   = time_constant;
-	txc->precision	   = 1;
-	txc->tolerance	   = MAXFREQ_SCALED / PPM_SCALE;
-	txc->tick	   = tick_usec;
-	txc->tai	   = *time_tai;
+	txc->freq = shift_right((tk_ntp.time_freq >> PPM_SCALE_INV_SHIFT) *
+		PPM_SCALE_INV, NTP_SCALE_SHIFT);
+	txc->maxerror = tk_ntp.time_maxerror;
+	txc->esterror = tk_ntp.time_esterror;
+	txc->status = tk_ntp.time_status;
+	txc->constant = tk_ntp.time_constant;
+	txc->precision = 1;
+	txc->tolerance = MAXFREQ_SCALED / PPM_SCALE;
+	txc->tick = tk_ntp.tick_usec;
+	txc->tai = *time_tai;
 
 	/* fill PPS status fields */
 	pps_fill_timex(txc);
 
 	txc->time.tv_sec = ts->tv_sec;
 	txc->time.tv_usec = ts->tv_nsec;
-	if (!(time_status & STA_NANO))
+	if (!(tk_ntp.time_status & STA_NANO))
 		txc->time.tv_usec /= NSEC_PER_USEC;
 
 	return result;
@@ -781,7 +742,7 @@ static long hardpps_update_freq(struct pps_normtime freq_norm)
 
 	/* check if the frequency interval was too long */
 	if (freq_norm.sec > (2 << pps_shift)) {
-		time_status |= STA_PPSERROR;
+		tk_ntp.time_status |= STA_PPSERROR;
 		pps_errcnt++;
 		pps_dec_freq_interval();
 		pr_err("hardpps: PPSERROR: interval too long - %ld s\n",
@@ -799,7 +760,7 @@ static long hardpps_update_freq(struct pps_normtime freq_norm)
 	pps_freq = ftemp;
 	if (delta > PPS_MAXWANDER || delta < -PPS_MAXWANDER) {
 		pr_warning("hardpps: PPSWANDER: change=%ld\n", delta);
-		time_status |= STA_PPSWANDER;
+		tk_ntp.time_status |= STA_PPSWANDER;
 		pps_stbcnt++;
 		pps_dec_freq_interval();
 	} else {	/* good sample */
@@ -818,9 +779,9 @@ static long hardpps_update_freq(struct pps_normtime freq_norm)
 				NSEC_PER_USEC) - pps_stabil) >> PPS_INTMIN;
 
 	/* if enabled, the system clock frequency is updated */
-	if ((time_status & STA_PPSFREQ) != 0 &&
-	    (time_status & STA_FREQHOLD) == 0) {
-		time_freq = pps_freq;
+	if ((tk_ntp.time_status & STA_PPSFREQ) != 0 &&
+	    (tk_ntp.time_status & STA_FREQHOLD) == 0) {
+		tk_ntp.time_freq = pps_freq;
 		ntp_update_frequency();
 	}
 
@@ -844,14 +805,15 @@ static void hardpps_update_phase(long error)
 	if (jitter > (pps_jitter << PPS_POPCORN)) {
 		pr_warning("hardpps: PPSJITTER: jitter=%ld, limit=%ld\n",
 		       jitter, (pps_jitter << PPS_POPCORN));
-		time_status |= STA_PPSJITTER;
+		tk_ntp.time_status |= STA_PPSJITTER;
 		pps_jitcnt++;
-	} else if (time_status & STA_PPSTIME) {
+	} else if (tk_ntp.time_status & STA_PPSTIME) {
 		/* correct the time using the phase offset */
-		time_offset = div_s64(((s64)correction) << NTP_SCALE_SHIFT,
+		tk_ntp.time_offset =
+			div_s64(((s64)correction) << NTP_SCALE_SHIFT,
 				NTP_INTERVAL_FREQ);
 		/* cancel running adjtime() */
-		time_adjust = 0;
+		tk_ntp.time_adjust = 0;
 	}
 	/* update jitter */
 	pps_jitter += (jitter - pps_jitter) >> PPS_INTMIN;
@@ -876,10 +838,10 @@ void __hardpps(const struct timespec *phase_ts, const struct timespec *raw_ts)
 	pts_norm = pps_normalize_ts(*phase_ts);
 
 	/* clear the error bits, they will be set again if needed */
-	time_status &= ~(STA_PPSJITTER | STA_PPSWANDER | STA_PPSERROR);
+	tk_ntp.time_status &= ~(STA_PPSJITTER | STA_PPSWANDER | STA_PPSERROR);
 
 	/* indicate signal presence */
-	time_status |= STA_PPSSIGNAL;
+	tk_ntp.time_status |= STA_PPSSIGNAL;
 	pps_valid = PPS_VALID;
 
 	/* when called for the first time,
@@ -897,7 +859,7 @@ void __hardpps(const struct timespec *phase_ts, const struct timespec *raw_ts)
 	if ((freq_norm.sec == 0) ||
 			(freq_norm.nsec > MAXFREQ * freq_norm.sec) ||
 			(freq_norm.nsec < -MAXFREQ * freq_norm.sec)) {
-		time_status |= STA_PPSJITTER;
+		tk_ntp.time_status |= STA_PPSJITTER;
 		/* restart the frequency calibration interval */
 		pps_fbase = *raw_ts;
 		pr_err("hardpps: PPSJITTER: bad pulse\n");
@@ -921,8 +883,8 @@ void __hardpps(const struct timespec *phase_ts, const struct timespec *raw_ts)
 
 static int __init ntp_tick_adj_setup(char *str)
 {
-	ntp_tick_adj = simple_strtol(str, NULL, 0);
-	ntp_tick_adj <<= NTP_SCALE_SHIFT;
+	tk_ntp.ntp_tick_adj = simple_strtol(str, NULL, 0);
+	tk_ntp.ntp_tick_adj <<= NTP_SCALE_SHIFT;
 
 	return 1;
 }
-- 
1.7.10.4

[PATCH 2/7] Move PPS variables into struct timekeeper_pps

[Mathieu Desnoyers]

Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Cc: John Stultz <john.stultz@linaro.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Peter Zijlstra <peterz@infradead.org>
---
 include/linux/timekeeper_internal.h |   31 ++++++++
 kernel/time/ntp.c                   |  134 +++++++++++++++--------------------
 2 files changed, 87 insertions(+), 78 deletions(-)

diff --git a/include/linux/timekeeper_internal.h b/include/linux/timekeeper_internal.h
index eab26e0..02c25c0 100644
--- a/include/linux/timekeeper_internal.h
+++ b/include/linux/timekeeper_internal.h
@@ -10,6 +10,32 @@
 #include <linux/jiffies.h>
 #include <linux/time.h>
 
+#ifdef CONFIG_NTP_PPS
+/*
+ * The following variables are used when a pulse-per-second (PPS) signal
+ * is available. They establish the engineering parameters of the clock
+ * discipline loop when controlled by the PPS signal.
+ */
+struct timekeeper_pps {
+	int valid;		/* signal watchdog counter */
+	long tf[3];		/* phase median filter */
+	long jitter;		/* current jitter (ns) */
+	struct timespec fbase;	/* beginning of the last freq interval */
+	int shift;		/* current interval duration (s) (shift) */
+	int intcnt;		/* interval counter */
+	s64 freq;		/* frequency offset (scaled ns/s) */
+	long stabil;		/* current stability (scaled ns/s) */
+
+	/*
+	 * PPS signal quality monitors
+	 */
+	long calcnt;		/* calibration intervals */
+	long jitcnt;		/* jitter limit exceeded */
+	long stbcnt;		/* stability limit exceeded */
+	long errcnt;		/* calibration errors */
+};
+#endif /* !CONFIG_NTP_PPS */
+
 /* structure holding internal NTP timekeeping values. */
 struct timekeeper_ntp {
 	/* USER_HZ period (usecs): */
@@ -55,6 +81,11 @@ struct timekeeper_ntp {
 
 	/* constant (boot-param configurable) NTP tick adjustment (upscaled) */
 	s64			ntp_tick_adj;
+
+#ifdef CONFIG_NTP_PPS
+	/* PPS variables */
+	struct timekeeper_pps   pps;
+#endif /* CONFIG_NTP_PPS */
 };
 
 /* Structure holding internal timekeeping values. */
diff --git a/kernel/time/ntp.c b/kernel/time/ntp.c
index 983c212..b095070 100644
--- a/kernel/time/ntp.c
+++ b/kernel/time/ntp.c
@@ -36,11 +36,6 @@ static struct timekeeper_ntp tk_ntp = {
 
 #ifdef CONFIG_NTP_PPS
 
-/*
- * The following variables are used when a pulse-per-second (PPS) signal
- * is available. They establish the engineering parameters of the clock
- * discipline loop when controlled by the PPS signal.
- */
 #define PPS_VALID	10	/* PPS signal watchdog max (s) */
 #define PPS_POPCORN	4	/* popcorn spike threshold (shift) */
 #define PPS_INTMIN	2	/* min freq interval (s) (shift) */
@@ -50,24 +45,6 @@ static struct timekeeper_ntp tk_ntp = {
 				   intervals to decrease it */
 #define PPS_MAXWANDER	100000	/* max PPS freq wander (ns/s) */
 
-static int pps_valid;		/* signal watchdog counter */
-static long pps_tf[3];		/* phase median filter */
-static long pps_jitter;		/* current jitter (ns) */
-static struct timespec pps_fbase; /* beginning of the last freq interval */
-static int pps_shift;		/* current interval duration (s) (shift) */
-static int pps_intcnt;		/* interval counter */
-static s64 pps_freq;		/* frequency offset (scaled ns/s) */
-static long pps_stabil;		/* current stability (scaled ns/s) */
-
-/*
- * PPS signal quality monitors
- */
-static long pps_calcnt;		/* calibration intervals */
-static long pps_jitcnt;		/* jitter limit exceeded */
-static long pps_stbcnt;		/* stability limit exceeded */
-static long pps_errcnt;		/* calibration errors */
-
-
 /* PPS kernel consumer compensates the whole phase error immediately.
  * Otherwise, reduce the offset by a fixed factor times the time constant.
  */
@@ -84,8 +61,8 @@ static inline void pps_reset_freq_interval(void)
 {
 	/* the PPS calibration interval may end
 	   surprisingly early */
-	pps_shift = PPS_INTMIN;
-	pps_intcnt = 0;
+	tk_ntp.pps.shift = PPS_INTMIN;
+	tk_ntp.pps.intcnt = 0;
 }
 
 /**
@@ -94,11 +71,11 @@ static inline void pps_reset_freq_interval(void)
 static inline void pps_clear(void)
 {
 	pps_reset_freq_interval();
-	pps_tf[0] = 0;
-	pps_tf[1] = 0;
-	pps_tf[2] = 0;
-	pps_fbase.tv_sec = pps_fbase.tv_nsec = 0;
-	pps_freq = 0;
+	tk_ntp.pps.tf[0] = 0;
+	tk_ntp.pps.tf[1] = 0;
+	tk_ntp.pps.tf[2] = 0;
+	tk_ntp.pps.fbase.tv_sec = tk_ntp.pps.fbase.tv_nsec = 0;
+	tk_ntp.pps.freq = 0;
 }
 
 /* Decrease pps_valid to indicate that another second has passed since
@@ -107,8 +84,8 @@ static inline void pps_clear(void)
  */
 static inline void pps_dec_valid(void)
 {
-	if (pps_valid > 0)
-		pps_valid--;
+	if (tk_ntp.pps.valid > 0)
+		tk_ntp.pps.valid--;
 	else {
 		tk_ntp.time_status &= ~(STA_PPSSIGNAL | STA_PPSJITTER |
 				 STA_PPSWANDER | STA_PPSERROR);
@@ -118,7 +95,7 @@ static inline void pps_dec_valid(void)
 
 static inline void pps_set_freq(s64 freq)
 {
-	pps_freq = freq;
+	tk_ntp.pps.freq = freq;
 }
 
 static inline int is_error_status(int status)
@@ -142,17 +119,17 @@ static inline int is_error_status(int status)
 
 static inline void pps_fill_timex(struct timex *txc)
 {
-	txc->ppsfreq	   = shift_right((pps_freq >> PPM_SCALE_INV_SHIFT) *
+	txc->ppsfreq = shift_right((tk_ntp.pps.freq >> PPM_SCALE_INV_SHIFT) *
 					 PPM_SCALE_INV, NTP_SCALE_SHIFT);
-	txc->jitter	   = pps_jitter;
+	txc->jitter = tk_ntp.pps.jitter;
 	if (!(tk_ntp.time_status & STA_NANO))
 		txc->jitter /= NSEC_PER_USEC;
-	txc->shift	   = pps_shift;
-	txc->stabil	   = pps_stabil;
-	txc->jitcnt	   = pps_jitcnt;
-	txc->calcnt	   = pps_calcnt;
-	txc->errcnt	   = pps_errcnt;
-	txc->stbcnt	   = pps_stbcnt;
+	txc->shift = tk_ntp.pps.shift;
+	txc->stabil = tk_ntp.pps.stabil;
+	txc->jitcnt = tk_ntp.pps.jitcnt;
+	txc->calcnt = tk_ntp.pps.calcnt;
+	txc->errcnt = tk_ntp.pps.errcnt;
+	txc->stbcnt = tk_ntp.pps.stbcnt;
 }
 
 #else /* !CONFIG_NTP_PPS */
@@ -528,7 +505,7 @@ static inline void process_adjtimex_modes(struct timex *txc,
 		tk_ntp.time_freq = txc->freq * PPM_SCALE;
 		tk_ntp.time_freq = min(tk_ntp.time_freq, MAXFREQ_SCALED);
 		tk_ntp.time_freq = max(tk_ntp.time_freq, -MAXFREQ_SCALED);
-		/* update pps_freq */
+		/* update tk_ntp.pps.freq */
 		pps_set_freq(tk_ntp.time_freq);
 	}
 
@@ -682,20 +659,20 @@ static inline struct pps_normtime pps_normalize_ts(struct timespec ts)
 /* get current phase correction and jitter */
 static inline long pps_phase_filter_get(long *jitter)
 {
-	*jitter = pps_tf[0] - pps_tf[1];
+	*jitter = tk_ntp.pps.tf[0] - tk_ntp.pps.tf[1];
 	if (*jitter < 0)
 		*jitter = -*jitter;
 
 	/* TODO: test various filters */
-	return pps_tf[0];
+	return tk_ntp.pps.tf[0];
 }
 
 /* add the sample to the phase filter */
 static inline void pps_phase_filter_add(long err)
 {
-	pps_tf[2] = pps_tf[1];
-	pps_tf[1] = pps_tf[0];
-	pps_tf[0] = err;
+	tk_ntp.pps.tf[2] = tk_ntp.pps.tf[1];
+	tk_ntp.pps.tf[1] = tk_ntp.pps.tf[0];
+	tk_ntp.pps.tf[0] = err;
 }
 
 /* decrease frequency calibration interval length.
@@ -703,11 +680,11 @@ static inline void pps_phase_filter_add(long err)
  */
 static inline void pps_dec_freq_interval(void)
 {
-	if (--pps_intcnt <= -PPS_INTCOUNT) {
-		pps_intcnt = -PPS_INTCOUNT;
-		if (pps_shift > PPS_INTMIN) {
-			pps_shift--;
-			pps_intcnt = 0;
+	if (--tk_ntp.pps.intcnt <= -PPS_INTCOUNT) {
+		tk_ntp.pps.intcnt = -PPS_INTCOUNT;
+		if (tk_ntp.pps.shift > PPS_INTMIN) {
+			tk_ntp.pps.shift--;
+			tk_ntp.pps.intcnt = 0;
 		}
 	}
 }
@@ -717,11 +694,11 @@ static inline void pps_dec_freq_interval(void)
  */
 static inline void pps_inc_freq_interval(void)
 {
-	if (++pps_intcnt >= PPS_INTCOUNT) {
-		pps_intcnt = PPS_INTCOUNT;
-		if (pps_shift < PPS_INTMAX) {
-			pps_shift++;
-			pps_intcnt = 0;
+	if (++tk_ntp.pps.intcnt >= PPS_INTCOUNT) {
+		tk_ntp.pps.intcnt = PPS_INTCOUNT;
+		if (tk_ntp.pps.shift < PPS_INTMAX) {
+			tk_ntp.pps.shift++;
+			tk_ntp.pps.intcnt = 0;
 		}
 	}
 }
@@ -741,9 +718,9 @@ static long hardpps_update_freq(struct pps_normtime freq_norm)
 	s64 ftemp;
 
 	/* check if the frequency interval was too long */
-	if (freq_norm.sec > (2 << pps_shift)) {
+	if (freq_norm.sec > (2 << tk_ntp.pps.shift)) {
 		tk_ntp.time_status |= STA_PPSERROR;
-		pps_errcnt++;
+		tk_ntp.pps.errcnt++;
 		pps_dec_freq_interval();
 		pr_err("hardpps: PPSERROR: interval too long - %ld s\n",
 				freq_norm.sec);
@@ -756,12 +733,12 @@ static long hardpps_update_freq(struct pps_normtime freq_norm)
 	 */
 	ftemp = div_s64(((s64)(-freq_norm.nsec)) << NTP_SCALE_SHIFT,
 			freq_norm.sec);
-	delta = shift_right(ftemp - pps_freq, NTP_SCALE_SHIFT);
-	pps_freq = ftemp;
+	delta = shift_right(ftemp - tk_ntp.pps.freq, NTP_SCALE_SHIFT);
+	tk_ntp.pps.freq = ftemp;
 	if (delta > PPS_MAXWANDER || delta < -PPS_MAXWANDER) {
 		pr_warning("hardpps: PPSWANDER: change=%ld\n", delta);
 		tk_ntp.time_status |= STA_PPSWANDER;
-		pps_stbcnt++;
+		tk_ntp.pps.stbcnt++;
 		pps_dec_freq_interval();
 	} else {	/* good sample */
 		pps_inc_freq_interval();
@@ -774,14 +751,14 @@ static long hardpps_update_freq(struct pps_normtime freq_norm)
 	delta_mod = delta;
 	if (delta_mod < 0)
 		delta_mod = -delta_mod;
-	pps_stabil += (div_s64(((s64)delta_mod) <<
-				(NTP_SCALE_SHIFT - SHIFT_USEC),
-				NSEC_PER_USEC) - pps_stabil) >> PPS_INTMIN;
+	tk_ntp.pps.stabil += (div_s64(((s64)delta_mod) <<
+		(NTP_SCALE_SHIFT - SHIFT_USEC),
+		NSEC_PER_USEC) - tk_ntp.pps.stabil) >> PPS_INTMIN;
 
 	/* if enabled, the system clock frequency is updated */
 	if ((tk_ntp.time_status & STA_PPSFREQ) != 0 &&
 	    (tk_ntp.time_status & STA_FREQHOLD) == 0) {
-		tk_ntp.time_freq = pps_freq;
+		tk_ntp.time_freq = tk_ntp.pps.freq;
 		ntp_update_frequency();
 	}
 
@@ -802,11 +779,11 @@ static void hardpps_update_phase(long error)
 	 * threshold, the sample is discarded; otherwise, if so enabled,
 	 * the time offset is updated.
 	 */
-	if (jitter > (pps_jitter << PPS_POPCORN)) {
+	if (jitter > (tk_ntp.pps.jitter << PPS_POPCORN)) {
 		pr_warning("hardpps: PPSJITTER: jitter=%ld, limit=%ld\n",
-		       jitter, (pps_jitter << PPS_POPCORN));
+		       jitter, (tk_ntp.pps.jitter << PPS_POPCORN));
 		tk_ntp.time_status |= STA_PPSJITTER;
-		pps_jitcnt++;
+		tk_ntp.pps.jitcnt++;
 	} else if (tk_ntp.time_status & STA_PPSTIME) {
 		/* correct the time using the phase offset */
 		tk_ntp.time_offset =
@@ -816,7 +793,7 @@ static void hardpps_update_phase(long error)
 		tk_ntp.time_adjust = 0;
 	}
 	/* update jitter */
-	pps_jitter += (jitter - pps_jitter) >> PPS_INTMIN;
+	tk_ntp.pps.jitter += (jitter - tk_ntp.pps.jitter) >> PPS_INTMIN;
 }
 
 /*
@@ -842,17 +819,18 @@ void __hardpps(const struct timespec *phase_ts, const struct timespec *raw_ts)
 
 	/* indicate signal presence */
 	tk_ntp.time_status |= STA_PPSSIGNAL;
-	pps_valid = PPS_VALID;
+	tk_ntp.pps.valid = PPS_VALID;
 
 	/* when called for the first time,
 	 * just start the frequency interval */
-	if (unlikely(pps_fbase.tv_sec == 0)) {
-		pps_fbase = *raw_ts;
+	if (unlikely(tk_ntp.pps.fbase.tv_sec == 0)) {
+		tk_ntp.pps.fbase = *raw_ts;
 		return;
 	}
 
 	/* ok, now we have a base for frequency calculation */
-	freq_norm = pps_normalize_ts(timespec_sub(*raw_ts, pps_fbase));
+	freq_norm = pps_normalize_ts(timespec_sub(*raw_ts,
+		tk_ntp.pps.fbase));
 
 	/* check that the signal is in the range
 	 * [1s - MAXFREQ us, 1s + MAXFREQ us], otherwise reject it */
@@ -861,7 +839,7 @@ void __hardpps(const struct timespec *phase_ts, const struct timespec *raw_ts)
 			(freq_norm.nsec < -MAXFREQ * freq_norm.sec)) {
 		tk_ntp.time_status |= STA_PPSJITTER;
 		/* restart the frequency calibration interval */
-		pps_fbase = *raw_ts;
+		tk_ntp.pps.fbase = *raw_ts;
 		pr_err("hardpps: PPSJITTER: bad pulse\n");
 		return;
 	}
@@ -869,10 +847,10 @@ void __hardpps(const struct timespec *phase_ts, const struct timespec *raw_ts)
 	/* signal is ok */
 
 	/* check if the current frequency interval is finished */
-	if (freq_norm.sec >= (1 << pps_shift)) {
-		pps_calcnt++;
+	if (freq_norm.sec >= (1 << tk_ntp.pps.shift)) {
+		tk_ntp.pps.calcnt++;
 		/* restart the frequency calibration interval */
-		pps_fbase = *raw_ts;
+		tk_ntp.pps.fbase = *raw_ts;
 		hardpps_update_freq(freq_norm);
 	}
 
-- 
1.7.10.4

[PATCH 3/7] Move ntp structure into struct timekeeper

[Mathieu Desnoyers]

This is in preparation for the latch synchronization scheme.

Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Cc: John Stultz <john.stultz@linaro.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Peter Zijlstra <peterz@infradead.org>
---
 include/linux/timekeeper_internal.h |    4 +
 kernel/time/ntp.c                   |  361 +++++++++++++++++------------------
 kernel/time/timekeeping.c           |   12 +-
 3 files changed, 191 insertions(+), 186 deletions(-)

diff --git a/include/linux/timekeeper_internal.h b/include/linux/timekeeper_internal.h
index 02c25c0..6f0532d 100644
--- a/include/linux/timekeeper_internal.h
+++ b/include/linux/timekeeper_internal.h
@@ -147,8 +147,12 @@ struct timekeeper {
 	/* Offset clock monotonic -> clock tai */
 	ktime_t			offs_tai;
 
+	/* NTP variables */
+	struct timekeeper_ntp	ntp;
 };
 
+extern struct timekeeper timekeeper;
+
 static inline struct timespec tk_xtime(struct timekeeper *tk)
 {
 	struct timespec ts;
diff --git a/kernel/time/ntp.c b/kernel/time/ntp.c
index b095070..d61e700 100644
--- a/kernel/time/ntp.c
+++ b/kernel/time/ntp.c
@@ -25,15 +25,6 @@
 #define MAX_TICKADJ_SCALED \
 	(((MAX_TICKADJ * NSEC_PER_USEC) << NTP_SCALE_SHIFT) / NTP_INTERVAL_FREQ)
 
-static struct timekeeper_ntp tk_ntp = {
-	.tick_usec = TICK_USEC,
-	.time_state = TIME_OK,
-	.time_status = STA_UNSYNC,
-	.time_constant = 2,
-	.time_maxerror = NTP_PHASE_LIMIT,
-	.time_esterror = NTP_PHASE_LIMIT,
-};
-
 #ifdef CONFIG_NTP_PPS
 
 #define PPS_VALID	10	/* PPS signal watchdog max (s) */
@@ -50,19 +41,19 @@ static struct timekeeper_ntp tk_ntp = {
  */
 static inline s64 ntp_offset_chunk(s64 offset)
 {
-	if (tk_ntp.time_status & STA_PPSTIME
-			&& tk_ntp.time_status & STA_PPSSIGNAL)
+	if (timekeeper.ntp.time_status & STA_PPSTIME
+			&& timekeeper.ntp.time_status & STA_PPSSIGNAL)
 		return offset;
 	else
-		return shift_right(offset, SHIFT_PLL + tk_ntp.time_constant);
+		return shift_right(offset, SHIFT_PLL + timekeeper.ntp.time_constant);
 }
 
 static inline void pps_reset_freq_interval(void)
 {
 	/* the PPS calibration interval may end
 	   surprisingly early */
-	tk_ntp.pps.shift = PPS_INTMIN;
-	tk_ntp.pps.intcnt = 0;
+	timekeeper.ntp.pps.shift = PPS_INTMIN;
+	timekeeper.ntp.pps.intcnt = 0;
 }
 
 /**
@@ -71,11 +62,11 @@ static inline void pps_reset_freq_interval(void)
 static inline void pps_clear(void)
 {
 	pps_reset_freq_interval();
-	tk_ntp.pps.tf[0] = 0;
-	tk_ntp.pps.tf[1] = 0;
-	tk_ntp.pps.tf[2] = 0;
-	tk_ntp.pps.fbase.tv_sec = tk_ntp.pps.fbase.tv_nsec = 0;
-	tk_ntp.pps.freq = 0;
+	timekeeper.ntp.pps.tf[0] = 0;
+	timekeeper.ntp.pps.tf[1] = 0;
+	timekeeper.ntp.pps.tf[2] = 0;
+	timekeeper.ntp.pps.fbase.tv_sec = timekeeper.ntp.pps.fbase.tv_nsec = 0;
+	timekeeper.ntp.pps.freq = 0;
 }
 
 /* Decrease pps_valid to indicate that another second has passed since
@@ -84,10 +75,10 @@ static inline void pps_clear(void)
  */
 static inline void pps_dec_valid(void)
 {
-	if (tk_ntp.pps.valid > 0)
-		tk_ntp.pps.valid--;
+	if (timekeeper.ntp.pps.valid > 0)
+		timekeeper.ntp.pps.valid--;
 	else {
-		tk_ntp.time_status &= ~(STA_PPSSIGNAL | STA_PPSJITTER |
+		timekeeper.ntp.time_status &= ~(STA_PPSSIGNAL | STA_PPSJITTER |
 				 STA_PPSWANDER | STA_PPSERROR);
 		pps_clear();
 	}
@@ -95,48 +86,48 @@ static inline void pps_dec_valid(void)
 
 static inline void pps_set_freq(s64 freq)
 {
-	tk_ntp.pps.freq = freq;
+	timekeeper.ntp.pps.freq = freq;
 }
 
 static inline int is_error_status(int status)
 {
-	return (tk_ntp.time_status & (STA_UNSYNC|STA_CLOCKERR))
+	return (timekeeper.ntp.time_status & (STA_UNSYNC|STA_CLOCKERR))
 		/* PPS signal lost when either PPS time or
 		 * PPS frequency synchronization requested
 		 */
-		|| ((tk_ntp.time_status & (STA_PPSFREQ|STA_PPSTIME))
-			&& !(tk_ntp.time_status & STA_PPSSIGNAL))
+		|| ((timekeeper.ntp.time_status & (STA_PPSFREQ|STA_PPSTIME))
+			&& !(timekeeper.ntp.time_status & STA_PPSSIGNAL))
 		/* PPS jitter exceeded when
 		 * PPS time synchronization requested */
-		|| ((tk_ntp.time_status & (STA_PPSTIME|STA_PPSJITTER))
+		|| ((timekeeper.ntp.time_status & (STA_PPSTIME|STA_PPSJITTER))
 			== (STA_PPSTIME|STA_PPSJITTER))
 		/* PPS wander exceeded or calibration error when
 		 * PPS frequency synchronization requested
 		 */
-		|| ((tk_ntp.time_status & STA_PPSFREQ)
-			&& (tk_ntp.time_status & (STA_PPSWANDER|STA_PPSERROR)));
+		|| ((timekeeper.ntp.time_status & STA_PPSFREQ)
+			&& (timekeeper.ntp.time_status & (STA_PPSWANDER|STA_PPSERROR)));
 }
 
 static inline void pps_fill_timex(struct timex *txc)
 {
-	txc->ppsfreq = shift_right((tk_ntp.pps.freq >> PPM_SCALE_INV_SHIFT) *
+	txc->ppsfreq = shift_right((timekeeper.ntp.pps.freq >> PPM_SCALE_INV_SHIFT) *
 					 PPM_SCALE_INV, NTP_SCALE_SHIFT);
-	txc->jitter = tk_ntp.pps.jitter;
-	if (!(tk_ntp.time_status & STA_NANO))
+	txc->jitter = timekeeper.ntp.pps.jitter;
+	if (!(timekeeper.ntp.time_status & STA_NANO))
 		txc->jitter /= NSEC_PER_USEC;
-	txc->shift = tk_ntp.pps.shift;
-	txc->stabil = tk_ntp.pps.stabil;
-	txc->jitcnt = tk_ntp.pps.jitcnt;
-	txc->calcnt = tk_ntp.pps.calcnt;
-	txc->errcnt = tk_ntp.pps.errcnt;
-	txc->stbcnt = tk_ntp.pps.stbcnt;
+	txc->shift = timekeeper.ntp.pps.shift;
+	txc->stabil = timekeeper.ntp.pps.stabil;
+	txc->jitcnt = timekeeper.ntp.pps.jitcnt;
+	txc->calcnt = timekeeper.ntp.pps.calcnt;
+	txc->errcnt = timekeeper.ntp.pps.errcnt;
+	txc->stbcnt = timekeeper.ntp.pps.stbcnt;
 }
 
 #else /* !CONFIG_NTP_PPS */
 
 static inline s64 ntp_offset_chunk(s64 offset)
 {
-	return shift_right(offset, SHIFT_PLL + tk_ntp.time_constant);
+	return shift_right(offset, SHIFT_PLL + timekeeper.ntp.time_constant);
 }
 
 static inline void pps_reset_freq_interval(void) {}
@@ -171,7 +162,7 @@ static inline void pps_fill_timex(struct timex *txc)
  */
 static inline int ntp_synced(void)
 {
-	return !(tk_ntp.time_status & STA_UNSYNC);
+	return !(timekeeper.ntp.time_status & STA_UNSYNC);
 }
 
 
@@ -180,42 +171,42 @@ static inline int ntp_synced(void)
  */
 
 /*
- * Update (tk_ntp.tick_length, tk_ntp.tick_length_base, tk_ntp.tick_nsec),
- * based on (tk_ntp.tick_usec, tk_ntp.ntp_tick_adj, tk_ntp.time_freq):
+ * Update (timekeeper.ntp.tick_length, timekeeper.ntp.tick_length_base, timekeeper.ntp.tick_nsec),
+ * based on (timekeeper.ntp.tick_usec, timekeeper.ntp.ntp_tick_adj, timekeeper.ntp.time_freq):
  */
 static void ntp_update_frequency(void)
 {
 	u64 second_length;
 	u64 new_base;
 
-	second_length = (u64)(tk_ntp.tick_usec * NSEC_PER_USEC * USER_HZ)
+	second_length = (u64)(timekeeper.ntp.tick_usec * NSEC_PER_USEC * USER_HZ)
 						<< NTP_SCALE_SHIFT;
 
-	second_length += tk_ntp.ntp_tick_adj;
-	second_length += tk_ntp.time_freq;
+	second_length += timekeeper.ntp.ntp_tick_adj;
+	second_length += timekeeper.ntp.time_freq;
 
-	tk_ntp.tick_nsec = div_u64(second_length, HZ) >> NTP_SCALE_SHIFT;
+	timekeeper.ntp.tick_nsec = div_u64(second_length, HZ) >> NTP_SCALE_SHIFT;
 	new_base = div_u64(second_length, NTP_INTERVAL_FREQ);
 
 	/*
 	 * Don't wait for the next second_overflow, apply
 	 * the change to the tick length immediately:
 	 */
-	tk_ntp.tick_length += new_base - tk_ntp.tick_length_base;
-	tk_ntp.tick_length_base = new_base;
+	timekeeper.ntp.tick_length += new_base - timekeeper.ntp.tick_length_base;
+	timekeeper.ntp.tick_length_base = new_base;
 }
 
 static inline s64 ntp_update_offset_fll(s64 offset64, long secs)
 {
-	tk_ntp.time_status &= ~STA_MODE;
+	timekeeper.ntp.time_status &= ~STA_MODE;
 
 	if (secs < MINSEC)
 		return 0;
 
-	if (!(tk_ntp.time_status & STA_FLL) && (secs <= MAXSEC))
+	if (!(timekeeper.ntp.time_status & STA_FLL) && (secs <= MAXSEC))
 		return 0;
 
-	tk_ntp.time_status |= STA_MODE;
+	timekeeper.ntp.time_status |= STA_MODE;
 
 	return div64_long(offset64 << (NTP_SCALE_SHIFT - SHIFT_FLL), secs);
 }
@@ -226,10 +217,10 @@ static void ntp_update_offset(long offset)
 	s64 offset64;
 	long secs;
 
-	if (!(tk_ntp.time_status & STA_PLL))
+	if (!(timekeeper.ntp.time_status & STA_PLL))
 		return;
 
-	if (!(tk_ntp.time_status & STA_NANO))
+	if (!(timekeeper.ntp.time_status & STA_NANO))
 		offset *= NSEC_PER_USEC;
 
 	/*
@@ -243,11 +234,11 @@ static void ntp_update_offset(long offset)
 	 * Select how the frequency is to be controlled
 	 * and in which mode (PLL or FLL).
 	 */
-	secs = get_seconds() - tk_ntp.time_reftime;
-	if (unlikely(tk_ntp.time_status & STA_FREQHOLD))
+	secs = get_seconds() - timekeeper.ntp.time_reftime;
+	if (unlikely(timekeeper.ntp.time_status & STA_FREQHOLD))
 		secs = 0;
 
-	tk_ntp.time_reftime = get_seconds();
+	timekeeper.ntp.time_reftime = get_seconds();
 
 	offset64    = offset;
 	freq_adj    = ntp_update_offset_fll(offset64, secs);
@@ -257,17 +248,17 @@ static void ntp_update_offset(long offset)
 	 * sampling rate (e.g. intermittent network connection)
 	 * to avoid instability.
 	 */
-	if (unlikely(secs > 1 << (SHIFT_PLL + 1 + tk_ntp.time_constant)))
-		secs = 1 << (SHIFT_PLL + 1 + tk_ntp.time_constant);
+	if (unlikely(secs > 1 << (SHIFT_PLL + 1 + timekeeper.ntp.time_constant)))
+		secs = 1 << (SHIFT_PLL + 1 + timekeeper.ntp.time_constant);
 
 	freq_adj    += (offset64 * secs) <<
-		(NTP_SCALE_SHIFT - 2 * (SHIFT_PLL + 2 + tk_ntp.time_constant));
+		(NTP_SCALE_SHIFT - 2 * (SHIFT_PLL + 2 + timekeeper.ntp.time_constant));
 
-	freq_adj    = min(freq_adj + tk_ntp.time_freq, MAXFREQ_SCALED);
+	freq_adj    = min(freq_adj + timekeeper.ntp.time_freq, MAXFREQ_SCALED);
 
-	tk_ntp.time_freq   = max(freq_adj, -MAXFREQ_SCALED);
+	timekeeper.ntp.time_freq   = max(freq_adj, -MAXFREQ_SCALED);
 
-	tk_ntp.time_offset = div_s64(offset64 << NTP_SCALE_SHIFT,
+	timekeeper.ntp.time_offset = div_s64(offset64 << NTP_SCALE_SHIFT,
 		NTP_INTERVAL_FREQ);
 }
 
@@ -276,15 +267,15 @@ static void ntp_update_offset(long offset)
  */
 void ntp_clear(void)
 {
-	tk_ntp.time_adjust	= 0;		/* stop active adjtime() */
-	tk_ntp.time_status	|= STA_UNSYNC;
-	tk_ntp.time_maxerror	= NTP_PHASE_LIMIT;
-	tk_ntp.time_esterror	= NTP_PHASE_LIMIT;
+	timekeeper.ntp.time_adjust	= 0;		/* stop active adjtime() */
+	timekeeper.ntp.time_status	|= STA_UNSYNC;
+	timekeeper.ntp.time_maxerror	= NTP_PHASE_LIMIT;
+	timekeeper.ntp.time_esterror	= NTP_PHASE_LIMIT;
 
 	ntp_update_frequency();
 
-	tk_ntp.tick_length	= tk_ntp.tick_length_base;
-	tk_ntp.time_offset	= 0;
+	timekeeper.ntp.tick_length	= timekeeper.ntp.tick_length_base;
+	timekeeper.ntp.time_offset	= 0;
 
 	/* Clear PPS state variables */
 	pps_clear();
@@ -293,7 +284,7 @@ void ntp_clear(void)
 
 u64 ntp_tick_length(void)
 {
-	return tk_ntp.tick_length;
+	return timekeeper.ntp.tick_length;
 }
 
 
@@ -317,80 +308,80 @@ int second_overflow(unsigned long secs)
 	 * day, the system clock is set back one second; if in leap-delete
 	 * state, the system clock is set ahead one second.
 	 */
-	switch (tk_ntp.time_state) {
+	switch (timekeeper.ntp.time_state) {
 	case TIME_OK:
-		if (tk_ntp.time_status & STA_INS)
-			tk_ntp.time_state = TIME_INS;
-		else if (tk_ntp.time_status & STA_DEL)
-			tk_ntp.time_state = TIME_DEL;
+		if (timekeeper.ntp.time_status & STA_INS)
+			timekeeper.ntp.time_state = TIME_INS;
+		else if (timekeeper.ntp.time_status & STA_DEL)
+			timekeeper.ntp.time_state = TIME_DEL;
 		break;
 	case TIME_INS:
-		if (!(tk_ntp.time_status & STA_INS))
-			tk_ntp.time_state = TIME_OK;
+		if (!(timekeeper.ntp.time_status & STA_INS))
+			timekeeper.ntp.time_state = TIME_OK;
 		else if (secs % 86400 == 0) {
 			leap = -1;
-			tk_ntp.time_state = TIME_OOP;
+			timekeeper.ntp.time_state = TIME_OOP;
 			printk(KERN_NOTICE
 				"Clock: inserting leap second 23:59:60 UTC\n");
 		}
 		break;
 	case TIME_DEL:
-		if (!(tk_ntp.time_status & STA_DEL))
-			tk_ntp.time_state = TIME_OK;
+		if (!(timekeeper.ntp.time_status & STA_DEL))
+			timekeeper.ntp.time_state = TIME_OK;
 		else if ((secs + 1) % 86400 == 0) {
 			leap = 1;
-			tk_ntp.time_state = TIME_WAIT;
+			timekeeper.ntp.time_state = TIME_WAIT;
 			printk(KERN_NOTICE
 				"Clock: deleting leap second 23:59:59 UTC\n");
 		}
 		break;
 	case TIME_OOP:
-		tk_ntp.time_state = TIME_WAIT;
+		timekeeper.ntp.time_state = TIME_WAIT;
 		break;
 
 	case TIME_WAIT:
-		if (!(tk_ntp.time_status & (STA_INS | STA_DEL)))
-			tk_ntp.time_state = TIME_OK;
+		if (!(timekeeper.ntp.time_status & (STA_INS | STA_DEL)))
+			timekeeper.ntp.time_state = TIME_OK;
 		break;
 	}
 
 
 	/* Bump the maxerror field */
-	tk_ntp.time_maxerror += MAXFREQ / NSEC_PER_USEC;
-	if (tk_ntp.time_maxerror > NTP_PHASE_LIMIT) {
-		tk_ntp.time_maxerror = NTP_PHASE_LIMIT;
-		tk_ntp.time_status |= STA_UNSYNC;
+	timekeeper.ntp.time_maxerror += MAXFREQ / NSEC_PER_USEC;
+	if (timekeeper.ntp.time_maxerror > NTP_PHASE_LIMIT) {
+		timekeeper.ntp.time_maxerror = NTP_PHASE_LIMIT;
+		timekeeper.ntp.time_status |= STA_UNSYNC;
 	}
 
 	/* Compute the phase adjustment for the next second */
-	tk_ntp.tick_length = tk_ntp.tick_length_base;
+	timekeeper.ntp.tick_length = timekeeper.ntp.tick_length_base;
 
-	delta = ntp_offset_chunk(tk_ntp.time_offset);
-	tk_ntp.time_offset -= delta;
-	tk_ntp.tick_length += delta;
+	delta = ntp_offset_chunk(timekeeper.ntp.time_offset);
+	timekeeper.ntp.time_offset -= delta;
+	timekeeper.ntp.tick_length += delta;
 
 	/* Check PPS signal */
 	pps_dec_valid();
 
-	if (!tk_ntp.time_adjust)
+	if (!timekeeper.ntp.time_adjust)
 		goto out;
 
-	if (tk_ntp.time_adjust > MAX_TICKADJ) {
-		tk_ntp.time_adjust -= MAX_TICKADJ;
-		tk_ntp.tick_length += MAX_TICKADJ_SCALED;
+	if (timekeeper.ntp.time_adjust > MAX_TICKADJ) {
+		timekeeper.ntp.time_adjust -= MAX_TICKADJ;
+		timekeeper.ntp.tick_length += MAX_TICKADJ_SCALED;
 		goto out;
 	}
 
-	if (tk_ntp.time_adjust < -MAX_TICKADJ) {
-		tk_ntp.time_adjust += MAX_TICKADJ;
-		tk_ntp.tick_length -= MAX_TICKADJ_SCALED;
+	if (timekeeper.ntp.time_adjust < -MAX_TICKADJ) {
+		timekeeper.ntp.time_adjust += MAX_TICKADJ;
+		timekeeper.ntp.tick_length -= MAX_TICKADJ_SCALED;
 		goto out;
 	}
 
-	tk_ntp.tick_length +=
-		(s64)(tk_ntp.time_adjust * NSEC_PER_USEC / NTP_INTERVAL_FREQ)
+	timekeeper.ntp.tick_length +=
+		(s64)(timekeeper.ntp.time_adjust * NSEC_PER_USEC / NTP_INTERVAL_FREQ)
 							 << NTP_SCALE_SHIFT;
-	tk_ntp.time_adjust = 0;
+	timekeeper.ntp.time_adjust = 0;
 
 out:
 	return leap;
@@ -422,7 +413,7 @@ static void sync_cmos_clock(struct work_struct *work)
 	}
 
 	getnstimeofday(&now);
-	if (abs(now.tv_nsec - (NSEC_PER_SEC / 2)) <= tk_ntp.tick_nsec / 2) {
+	if (abs(now.tv_nsec - (NSEC_PER_SEC / 2)) <= timekeeper.ntp.tick_nsec / 2) {
 		struct timespec adjust = now;
 
 		fail = -ENODEV;
@@ -468,9 +459,9 @@ void ntp_notify_cmos_timer(void) { }
  */
 static inline void process_adj_status(struct timex *txc, struct timespec *ts)
 {
-	if ((tk_ntp.time_status & STA_PLL) && !(txc->status & STA_PLL)) {
-		tk_ntp.time_state = TIME_OK;
-		tk_ntp.time_status = STA_UNSYNC;
+	if ((timekeeper.ntp.time_status & STA_PLL) && !(txc->status & STA_PLL)) {
+		timekeeper.ntp.time_state = TIME_OK;
+		timekeeper.ntp.time_status = STA_UNSYNC;
 		/* restart PPS frequency calibration */
 		pps_reset_freq_interval();
 	}
@@ -479,12 +470,12 @@ static inline void process_adj_status(struct timex *txc, struct timespec *ts)
 	 * If we turn on PLL adjustments then reset the
 	 * reference time to current time.
 	 */
-	if (!(tk_ntp.time_status & STA_PLL) && (txc->status & STA_PLL))
-		tk_ntp.time_reftime = get_seconds();
+	if (!(timekeeper.ntp.time_status & STA_PLL) && (txc->status & STA_PLL))
+		timekeeper.ntp.time_reftime = get_seconds();
 
 	/* only set allowed bits */
-	tk_ntp.time_status &= STA_RONLY;
-	tk_ntp.time_status |= txc->status & ~STA_RONLY;
+	timekeeper.ntp.time_status &= STA_RONLY;
+	timekeeper.ntp.time_status |= txc->status & ~STA_RONLY;
 }
 
 
@@ -496,31 +487,31 @@ static inline void process_adjtimex_modes(struct timex *txc,
 		process_adj_status(txc, ts);
 
 	if (txc->modes & ADJ_NANO)
-		tk_ntp.time_status |= STA_NANO;
+		timekeeper.ntp.time_status |= STA_NANO;
 
 	if (txc->modes & ADJ_MICRO)
-		tk_ntp.time_status &= ~STA_NANO;
+		timekeeper.ntp.time_status &= ~STA_NANO;
 
 	if (txc->modes & ADJ_FREQUENCY) {
-		tk_ntp.time_freq = txc->freq * PPM_SCALE;
-		tk_ntp.time_freq = min(tk_ntp.time_freq, MAXFREQ_SCALED);
-		tk_ntp.time_freq = max(tk_ntp.time_freq, -MAXFREQ_SCALED);
-		/* update tk_ntp.pps.freq */
-		pps_set_freq(tk_ntp.time_freq);
+		timekeeper.ntp.time_freq = txc->freq * PPM_SCALE;
+		timekeeper.ntp.time_freq = min(timekeeper.ntp.time_freq, MAXFREQ_SCALED);
+		timekeeper.ntp.time_freq = max(timekeeper.ntp.time_freq, -MAXFREQ_SCALED);
+		/* update timekeeper.ntp.pps.freq */
+		pps_set_freq(timekeeper.ntp.time_freq);
 	}
 
 	if (txc->modes & ADJ_MAXERROR)
-		tk_ntp.time_maxerror = txc->maxerror;
+		timekeeper.ntp.time_maxerror = txc->maxerror;
 
 	if (txc->modes & ADJ_ESTERROR)
-		tk_ntp.time_esterror = txc->esterror;
+		timekeeper.ntp.time_esterror = txc->esterror;
 
 	if (txc->modes & ADJ_TIMECONST) {
-		tk_ntp.time_constant = txc->constant;
-		if (!(tk_ntp.time_status & STA_NANO))
-			tk_ntp.time_constant += 4;
-		tk_ntp.time_constant = min(tk_ntp.time_constant, (long)MAXTC);
-		tk_ntp.time_constant = max(tk_ntp.time_constant, 0l);
+		timekeeper.ntp.time_constant = txc->constant;
+		if (!(timekeeper.ntp.time_status & STA_NANO))
+			timekeeper.ntp.time_constant += 4;
+		timekeeper.ntp.time_constant = min(timekeeper.ntp.time_constant, (long)MAXTC);
+		timekeeper.ntp.time_constant = max(timekeeper.ntp.time_constant, 0l);
 	}
 
 	if (txc->modes & ADJ_TAI && txc->constant > 0)
@@ -530,7 +521,7 @@ static inline void process_adjtimex_modes(struct timex *txc,
 		ntp_update_offset(txc->offset);
 
 	if (txc->modes & ADJ_TICK)
-		tk_ntp.tick_usec = txc->tick;
+		timekeeper.ntp.tick_usec = txc->tick;
 
 	if (txc->modes & (ADJ_TICK|ADJ_FREQUENCY|ADJ_OFFSET))
 		ntp_update_frequency();
@@ -580,11 +571,11 @@ int __do_adjtimex(struct timex *txc, struct timespec *ts, s32 *time_tai)
 	int result;
 
 	if (txc->modes & ADJ_ADJTIME) {
-		long save_adjust = tk_ntp.time_adjust;
+		long save_adjust = timekeeper.ntp.time_adjust;
 
 		if (!(txc->modes & ADJ_OFFSET_READONLY)) {
 			/* adjtime() is independent from ntp_adjtime() */
-			tk_ntp.time_adjust = txc->offset;
+			timekeeper.ntp.time_adjust = txc->offset;
 			ntp_update_frequency();
 		}
 		txc->offset = save_adjust;
@@ -595,26 +586,26 @@ int __do_adjtimex(struct timex *txc, struct timespec *ts, s32 *time_tai)
 			process_adjtimex_modes(txc, ts, time_tai);
 
 		txc->offset =
-			shift_right(tk_ntp.time_offset * NTP_INTERVAL_FREQ,
+			shift_right(timekeeper.ntp.time_offset * NTP_INTERVAL_FREQ,
 				  NTP_SCALE_SHIFT);
-		if (!(tk_ntp.time_status & STA_NANO))
+		if (!(timekeeper.ntp.time_status & STA_NANO))
 			txc->offset /= NSEC_PER_USEC;
 	}
 
-	result = tk_ntp.time_state;	/* mostly `TIME_OK' */
+	result = timekeeper.ntp.time_state;	/* mostly `TIME_OK' */
 	/* check for errors */
-	if (is_error_status(tk_ntp.time_status))
+	if (is_error_status(timekeeper.ntp.time_status))
 		result = TIME_ERROR;
 
-	txc->freq = shift_right((tk_ntp.time_freq >> PPM_SCALE_INV_SHIFT) *
+	txc->freq = shift_right((timekeeper.ntp.time_freq >> PPM_SCALE_INV_SHIFT) *
 		PPM_SCALE_INV, NTP_SCALE_SHIFT);
-	txc->maxerror = tk_ntp.time_maxerror;
-	txc->esterror = tk_ntp.time_esterror;
-	txc->status = tk_ntp.time_status;
-	txc->constant = tk_ntp.time_constant;
+	txc->maxerror = timekeeper.ntp.time_maxerror;
+	txc->esterror = timekeeper.ntp.time_esterror;
+	txc->status = timekeeper.ntp.time_status;
+	txc->constant = timekeeper.ntp.time_constant;
 	txc->precision = 1;
 	txc->tolerance = MAXFREQ_SCALED / PPM_SCALE;
-	txc->tick = tk_ntp.tick_usec;
+	txc->tick = timekeeper.ntp.tick_usec;
 	txc->tai = *time_tai;
 
 	/* fill PPS status fields */
@@ -622,7 +613,7 @@ int __do_adjtimex(struct timex *txc, struct timespec *ts, s32 *time_tai)
 
 	txc->time.tv_sec = ts->tv_sec;
 	txc->time.tv_usec = ts->tv_nsec;
-	if (!(tk_ntp.time_status & STA_NANO))
+	if (!(timekeeper.ntp.time_status & STA_NANO))
 		txc->time.tv_usec /= NSEC_PER_USEC;
 
 	return result;
@@ -659,20 +650,20 @@ static inline struct pps_normtime pps_normalize_ts(struct timespec ts)
 /* get current phase correction and jitter */
 static inline long pps_phase_filter_get(long *jitter)
 {
-	*jitter = tk_ntp.pps.tf[0] - tk_ntp.pps.tf[1];
+	*jitter = timekeeper.ntp.pps.tf[0] - timekeeper.ntp.pps.tf[1];
 	if (*jitter < 0)
 		*jitter = -*jitter;
 
 	/* TODO: test various filters */
-	return tk_ntp.pps.tf[0];
+	return timekeeper.ntp.pps.tf[0];
 }
 
 /* add the sample to the phase filter */
 static inline void pps_phase_filter_add(long err)
 {
-	tk_ntp.pps.tf[2] = tk_ntp.pps.tf[1];
-	tk_ntp.pps.tf[1] = tk_ntp.pps.tf[0];
-	tk_ntp.pps.tf[0] = err;
+	timekeeper.ntp.pps.tf[2] = timekeeper.ntp.pps.tf[1];
+	timekeeper.ntp.pps.tf[1] = timekeeper.ntp.pps.tf[0];
+	timekeeper.ntp.pps.tf[0] = err;
 }
 
 /* decrease frequency calibration interval length.
@@ -680,11 +671,11 @@ static inline void pps_phase_filter_add(long err)
  */
 static inline void pps_dec_freq_interval(void)
 {
-	if (--tk_ntp.pps.intcnt <= -PPS_INTCOUNT) {
-		tk_ntp.pps.intcnt = -PPS_INTCOUNT;
-		if (tk_ntp.pps.shift > PPS_INTMIN) {
-			tk_ntp.pps.shift--;
-			tk_ntp.pps.intcnt = 0;
+	if (--timekeeper.ntp.pps.intcnt <= -PPS_INTCOUNT) {
+		timekeeper.ntp.pps.intcnt = -PPS_INTCOUNT;
+		if (timekeeper.ntp.pps.shift > PPS_INTMIN) {
+			timekeeper.ntp.pps.shift--;
+			timekeeper.ntp.pps.intcnt = 0;
 		}
 	}
 }
@@ -694,11 +685,11 @@ static inline void pps_dec_freq_interval(void)
  */
 static inline void pps_inc_freq_interval(void)
 {
-	if (++tk_ntp.pps.intcnt >= PPS_INTCOUNT) {
-		tk_ntp.pps.intcnt = PPS_INTCOUNT;
-		if (tk_ntp.pps.shift < PPS_INTMAX) {
-			tk_ntp.pps.shift++;
-			tk_ntp.pps.intcnt = 0;
+	if (++timekeeper.ntp.pps.intcnt >= PPS_INTCOUNT) {
+		timekeeper.ntp.pps.intcnt = PPS_INTCOUNT;
+		if (timekeeper.ntp.pps.shift < PPS_INTMAX) {
+			timekeeper.ntp.pps.shift++;
+			timekeeper.ntp.pps.intcnt = 0;
 		}
 	}
 }
@@ -718,9 +709,9 @@ static long hardpps_update_freq(struct pps_normtime freq_norm)
 	s64 ftemp;
 
 	/* check if the frequency interval was too long */
-	if (freq_norm.sec > (2 << tk_ntp.pps.shift)) {
-		tk_ntp.time_status |= STA_PPSERROR;
-		tk_ntp.pps.errcnt++;
+	if (freq_norm.sec > (2 << timekeeper.ntp.pps.shift)) {
+		timekeeper.ntp.time_status |= STA_PPSERROR;
+		timekeeper.ntp.pps.errcnt++;
 		pps_dec_freq_interval();
 		pr_err("hardpps: PPSERROR: interval too long - %ld s\n",
 				freq_norm.sec);
@@ -733,12 +724,12 @@ static long hardpps_update_freq(struct pps_normtime freq_norm)
 	 */
 	ftemp = div_s64(((s64)(-freq_norm.nsec)) << NTP_SCALE_SHIFT,
 			freq_norm.sec);
-	delta = shift_right(ftemp - tk_ntp.pps.freq, NTP_SCALE_SHIFT);
-	tk_ntp.pps.freq = ftemp;
+	delta = shift_right(ftemp - timekeeper.ntp.pps.freq, NTP_SCALE_SHIFT);
+	timekeeper.ntp.pps.freq = ftemp;
 	if (delta > PPS_MAXWANDER || delta < -PPS_MAXWANDER) {
 		pr_warning("hardpps: PPSWANDER: change=%ld\n", delta);
-		tk_ntp.time_status |= STA_PPSWANDER;
-		tk_ntp.pps.stbcnt++;
+		timekeeper.ntp.time_status |= STA_PPSWANDER;
+		timekeeper.ntp.pps.stbcnt++;
 		pps_dec_freq_interval();
 	} else {	/* good sample */
 		pps_inc_freq_interval();
@@ -751,14 +742,14 @@ static long hardpps_update_freq(struct pps_normtime freq_norm)
 	delta_mod = delta;
 	if (delta_mod < 0)
 		delta_mod = -delta_mod;
-	tk_ntp.pps.stabil += (div_s64(((s64)delta_mod) <<
+	timekeeper.ntp.pps.stabil += (div_s64(((s64)delta_mod) <<
 		(NTP_SCALE_SHIFT - SHIFT_USEC),
-		NSEC_PER_USEC) - tk_ntp.pps.stabil) >> PPS_INTMIN;
+		NSEC_PER_USEC) - timekeeper.ntp.pps.stabil) >> PPS_INTMIN;
 
 	/* if enabled, the system clock frequency is updated */
-	if ((tk_ntp.time_status & STA_PPSFREQ) != 0 &&
-	    (tk_ntp.time_status & STA_FREQHOLD) == 0) {
-		tk_ntp.time_freq = tk_ntp.pps.freq;
+	if ((timekeeper.ntp.time_status & STA_PPSFREQ) != 0 &&
+	    (timekeeper.ntp.time_status & STA_FREQHOLD) == 0) {
+		timekeeper.ntp.time_freq = timekeeper.ntp.pps.freq;
 		ntp_update_frequency();
 	}
 
@@ -779,21 +770,21 @@ static void hardpps_update_phase(long error)
 	 * threshold, the sample is discarded; otherwise, if so enabled,
 	 * the time offset is updated.
 	 */
-	if (jitter > (tk_ntp.pps.jitter << PPS_POPCORN)) {
+	if (jitter > (timekeeper.ntp.pps.jitter << PPS_POPCORN)) {
 		pr_warning("hardpps: PPSJITTER: jitter=%ld, limit=%ld\n",
-		       jitter, (tk_ntp.pps.jitter << PPS_POPCORN));
-		tk_ntp.time_status |= STA_PPSJITTER;
-		tk_ntp.pps.jitcnt++;
-	} else if (tk_ntp.time_status & STA_PPSTIME) {
+		       jitter, (timekeeper.ntp.pps.jitter << PPS_POPCORN));
+		timekeeper.ntp.time_status |= STA_PPSJITTER;
+		timekeeper.ntp.pps.jitcnt++;
+	} else if (timekeeper.ntp.time_status & STA_PPSTIME) {
 		/* correct the time using the phase offset */
-		tk_ntp.time_offset =
+		timekeeper.ntp.time_offset =
 			div_s64(((s64)correction) << NTP_SCALE_SHIFT,
 				NTP_INTERVAL_FREQ);
 		/* cancel running adjtime() */
-		tk_ntp.time_adjust = 0;
+		timekeeper.ntp.time_adjust = 0;
 	}
 	/* update jitter */
-	tk_ntp.pps.jitter += (jitter - tk_ntp.pps.jitter) >> PPS_INTMIN;
+	timekeeper.ntp.pps.jitter += (jitter - timekeeper.ntp.pps.jitter) >> PPS_INTMIN;
 }
 
 /*
@@ -815,31 +806,31 @@ void __hardpps(const struct timespec *phase_ts, const struct timespec *raw_ts)
 	pts_norm = pps_normalize_ts(*phase_ts);
 
 	/* clear the error bits, they will be set again if needed */
-	tk_ntp.time_status &= ~(STA_PPSJITTER | STA_PPSWANDER | STA_PPSERROR);
+	timekeeper.ntp.time_status &= ~(STA_PPSJITTER | STA_PPSWANDER | STA_PPSERROR);
 
 	/* indicate signal presence */
-	tk_ntp.time_status |= STA_PPSSIGNAL;
-	tk_ntp.pps.valid = PPS_VALID;
+	timekeeper.ntp.time_status |= STA_PPSSIGNAL;
+	timekeeper.ntp.pps.valid = PPS_VALID;
 
 	/* when called for the first time,
 	 * just start the frequency interval */
-	if (unlikely(tk_ntp.pps.fbase.tv_sec == 0)) {
-		tk_ntp.pps.fbase = *raw_ts;
+	if (unlikely(timekeeper.ntp.pps.fbase.tv_sec == 0)) {
+		timekeeper.ntp.pps.fbase = *raw_ts;
 		return;
 	}
 
 	/* ok, now we have a base for frequency calculation */
 	freq_norm = pps_normalize_ts(timespec_sub(*raw_ts,
-		tk_ntp.pps.fbase));
+		timekeeper.ntp.pps.fbase));
 
 	/* check that the signal is in the range
 	 * [1s - MAXFREQ us, 1s + MAXFREQ us], otherwise reject it */
 	if ((freq_norm.sec == 0) ||
 			(freq_norm.nsec > MAXFREQ * freq_norm.sec) ||
 			(freq_norm.nsec < -MAXFREQ * freq_norm.sec)) {
-		tk_ntp.time_status |= STA_PPSJITTER;
+		timekeeper.ntp.time_status |= STA_PPSJITTER;
 		/* restart the frequency calibration interval */
-		tk_ntp.pps.fbase = *raw_ts;
+		timekeeper.ntp.pps.fbase = *raw_ts;
 		pr_err("hardpps: PPSJITTER: bad pulse\n");
 		return;
 	}
@@ -847,10 +838,10 @@ void __hardpps(const struct timespec *phase_ts, const struct timespec *raw_ts)
 	/* signal is ok */
 
 	/* check if the current frequency interval is finished */
-	if (freq_norm.sec >= (1 << tk_ntp.pps.shift)) {
-		tk_ntp.pps.calcnt++;
+	if (freq_norm.sec >= (1 << timekeeper.ntp.pps.shift)) {
+		timekeeper.ntp.pps.calcnt++;
 		/* restart the frequency calibration interval */
-		tk_ntp.pps.fbase = *raw_ts;
+		timekeeper.ntp.pps.fbase = *raw_ts;
 		hardpps_update_freq(freq_norm);
 	}
 
@@ -861,8 +852,8 @@ void __hardpps(const struct timespec *phase_ts, const struct timespec *raw_ts)
 
 static int __init ntp_tick_adj_setup(char *str)
 {
-	tk_ntp.ntp_tick_adj = simple_strtol(str, NULL, 0);
-	tk_ntp.ntp_tick_adj <<= NTP_SCALE_SHIFT;
+	timekeeper.ntp.ntp_tick_adj = simple_strtol(str, NULL, 0);
+	timekeeper.ntp.ntp_tick_adj <<= NTP_SCALE_SHIFT;
 
 	return 1;
 }
diff --git a/kernel/time/timekeeping.c b/kernel/time/timekeeping.c
index 947ba25..d1ecafb 100644
--- a/kernel/time/timekeeping.c
+++ b/kernel/time/timekeeping.c
@@ -31,7 +31,17 @@
 #define TK_MIRROR		(1 << 1)
 #define TK_CLOCK_WAS_SET	(1 << 2)
 
-static struct timekeeper timekeeper;
+struct timekeeper timekeeper = {
+	.ntp = {
+		.tick_usec = TICK_USEC,
+		.time_state = TIME_OK,
+		.time_status = STA_UNSYNC,
+		.time_constant = 2,
+		.time_maxerror = NTP_PHASE_LIMIT,
+		.time_esterror = NTP_PHASE_LIMIT,
+	},
+};
+
 static DEFINE_RAW_SPINLOCK(timekeeper_lock);
 static seqcount_t timekeeper_seq;
 static struct timekeeper shadow_timekeeper;
-- 
1.7.10.4

[PATCH 4/7] Pass struct timekeeper_ntp as parameter from timekeeper to ntp

[Mathieu Desnoyers]

This is in preparation for the latch synchronization scheme.

Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Cc: John Stultz <john.stultz@linaro.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Peter Zijlstra <peterz@infradead.org>
---
 kernel/time/ntp.c          |  472 ++++++++++++++++++++++----------------------
 kernel/time/ntp_internal.h |   16 +-
 kernel/time/timekeeping.c  |   17 +-
 3 files changed, 260 insertions(+), 245 deletions(-)

diff --git a/kernel/time/ntp.c b/kernel/time/ntp.c
index d61e700..2a1b4ef 100644
--- a/kernel/time/ntp.c
+++ b/kernel/time/ntp.c
@@ -39,108 +39,108 @@
 /* PPS kernel consumer compensates the whole phase error immediately.
  * Otherwise, reduce the offset by a fixed factor times the time constant.
  */
-static inline s64 ntp_offset_chunk(s64 offset)
+static inline s64 ntp_offset_chunk(struct timekeeper_ntp *ntp, s64 offset)
 {
-	if (timekeeper.ntp.time_status & STA_PPSTIME
-			&& timekeeper.ntp.time_status & STA_PPSSIGNAL)
+	if (ntp->time_status & STA_PPSTIME
+			&& ntp->time_status & STA_PPSSIGNAL)
 		return offset;
 	else
-		return shift_right(offset, SHIFT_PLL + timekeeper.ntp.time_constant);
+		return shift_right(offset, SHIFT_PLL + ntp->time_constant);
 }
 
-static inline void pps_reset_freq_interval(void)
+static inline void pps_reset_freq_interval(struct timekeeper_ntp *ntp)
 {
 	/* the PPS calibration interval may end
 	   surprisingly early */
-	timekeeper.ntp.pps.shift = PPS_INTMIN;
-	timekeeper.ntp.pps.intcnt = 0;
+	ntp->pps.shift = PPS_INTMIN;
+	ntp->pps.intcnt = 0;
 }
 
 /**
  * pps_clear - Clears the PPS state variables
  */
-static inline void pps_clear(void)
+static inline void pps_clear(struct timekeeper_ntp *ntp)
 {
-	pps_reset_freq_interval();
-	timekeeper.ntp.pps.tf[0] = 0;
-	timekeeper.ntp.pps.tf[1] = 0;
-	timekeeper.ntp.pps.tf[2] = 0;
-	timekeeper.ntp.pps.fbase.tv_sec = timekeeper.ntp.pps.fbase.tv_nsec = 0;
-	timekeeper.ntp.pps.freq = 0;
+	pps_reset_freq_interval(ntp);
+	ntp->pps.tf[0] = 0;
+	ntp->pps.tf[1] = 0;
+	ntp->pps.tf[2] = 0;
+	ntp->pps.fbase.tv_sec = ntp->pps.fbase.tv_nsec = 0;
+	ntp->pps.freq = 0;
 }
 
 /* Decrease pps_valid to indicate that another second has passed since
  * the last PPS signal. When it reaches 0, indicate that PPS signal is
  * missing.
  */
-static inline void pps_dec_valid(void)
+static inline void pps_dec_valid(struct timekeeper_ntp *ntp)
 {
-	if (timekeeper.ntp.pps.valid > 0)
-		timekeeper.ntp.pps.valid--;
+	if (ntp->pps.valid > 0)
+		ntp->pps.valid--;
 	else {
-		timekeeper.ntp.time_status &= ~(STA_PPSSIGNAL | STA_PPSJITTER |
+		ntp->time_status &= ~(STA_PPSSIGNAL | STA_PPSJITTER |
 				 STA_PPSWANDER | STA_PPSERROR);
-		pps_clear();
+		pps_clear(ntp);
 	}
 }
 
-static inline void pps_set_freq(s64 freq)
+static inline void pps_set_freq(struct timekeeper_ntp *ntp, s64 freq)
 {
-	timekeeper.ntp.pps.freq = freq;
+	ntp->pps.freq = freq;
 }
 
-static inline int is_error_status(int status)
+static inline int is_error_status(struct timekeeper_ntp *ntp, int status)
 {
-	return (timekeeper.ntp.time_status & (STA_UNSYNC|STA_CLOCKERR))
+	return (ntp->time_status & (STA_UNSYNC|STA_CLOCKERR))
 		/* PPS signal lost when either PPS time or
 		 * PPS frequency synchronization requested
 		 */
-		|| ((timekeeper.ntp.time_status & (STA_PPSFREQ|STA_PPSTIME))
-			&& !(timekeeper.ntp.time_status & STA_PPSSIGNAL))
+		|| ((ntp->time_status & (STA_PPSFREQ|STA_PPSTIME))
+			&& !(ntp->time_status & STA_PPSSIGNAL))
 		/* PPS jitter exceeded when
 		 * PPS time synchronization requested */
-		|| ((timekeeper.ntp.time_status & (STA_PPSTIME|STA_PPSJITTER))
+		|| ((ntp->time_status & (STA_PPSTIME|STA_PPSJITTER))
 			== (STA_PPSTIME|STA_PPSJITTER))
 		/* PPS wander exceeded or calibration error when
 		 * PPS frequency synchronization requested
 		 */
-		|| ((timekeeper.ntp.time_status & STA_PPSFREQ)
-			&& (timekeeper.ntp.time_status & (STA_PPSWANDER|STA_PPSERROR)));
+		|| ((ntp->time_status & STA_PPSFREQ)
+			&& (ntp->time_status & (STA_PPSWANDER|STA_PPSERROR)));
 }
 
-static inline void pps_fill_timex(struct timex *txc)
+static inline void pps_fill_timex(struct timekeeper_ntp *ntp, struct timex *txc)
 {
-	txc->ppsfreq = shift_right((timekeeper.ntp.pps.freq >> PPM_SCALE_INV_SHIFT) *
+	txc->ppsfreq = shift_right((ntp->pps.freq >> PPM_SCALE_INV_SHIFT) *
 					 PPM_SCALE_INV, NTP_SCALE_SHIFT);
-	txc->jitter = timekeeper.ntp.pps.jitter;
-	if (!(timekeeper.ntp.time_status & STA_NANO))
+	txc->jitter = ntp->pps.jitter;
+	if (!(ntp->time_status & STA_NANO))
 		txc->jitter /= NSEC_PER_USEC;
-	txc->shift = timekeeper.ntp.pps.shift;
-	txc->stabil = timekeeper.ntp.pps.stabil;
-	txc->jitcnt = timekeeper.ntp.pps.jitcnt;
-	txc->calcnt = timekeeper.ntp.pps.calcnt;
-	txc->errcnt = timekeeper.ntp.pps.errcnt;
-	txc->stbcnt = timekeeper.ntp.pps.stbcnt;
+	txc->shift = ntp->pps.shift;
+	txc->stabil = ntp->pps.stabil;
+	txc->jitcnt = ntp->pps.jitcnt;
+	txc->calcnt = ntp->pps.calcnt;
+	txc->errcnt = ntp->pps.errcnt;
+	txc->stbcnt = ntp->pps.stbcnt;
 }
 
 #else /* !CONFIG_NTP_PPS */
 
-static inline s64 ntp_offset_chunk(s64 offset)
+static inline s64 ntp_offset_chunk(struct timekeeper_ntp *ntp, s64 offset)
 {
-	return shift_right(offset, SHIFT_PLL + timekeeper.ntp.time_constant);
+	return shift_right(offset, SHIFT_PLL + ntp->time_constant);
 }
 
-static inline void pps_reset_freq_interval(void) {}
-static inline void pps_clear(void) {}
-static inline void pps_dec_valid(void) {}
-static inline void pps_set_freq(s64 freq) {}
+static inline void pps_reset_freq_interval(struct timekeeper_ntp *ntp) {}
+static inline void pps_clear(struct timekeeper_ntp *ntp) {}
+static inline void pps_dec_valid(struct timekeeper_ntp *ntp) {}
+static inline void pps_set_freq(struct timekeeper_ntp *ntp, s64 freq) {}
 
-static inline int is_error_status(int status)
+static inline int is_error_status(struct timekeeper_ntp *ntp, int status)
 {
 	return status & (STA_UNSYNC|STA_CLOCKERR);
 }
 
-static inline void pps_fill_timex(struct timex *txc)
+static inline void pps_fill_timex(struct timekeeper_ntp *ntp, struct timex *txc)
 {
 	/* PPS is not implemented, so these are zero */
 	txc->ppsfreq	   = 0;
@@ -160,9 +160,9 @@ static inline void pps_fill_timex(struct timex *txc)
  * ntp_synced - Returns 1 if the NTP status is not UNSYNC
  *
  */
-static inline int ntp_synced(void)
+static inline int ntp_synced(struct timekeeper_ntp *ntp)
 {
-	return !(timekeeper.ntp.time_status & STA_UNSYNC);
+	return !(ntp->time_status & STA_UNSYNC);
 }
 
 
@@ -171,56 +171,57 @@ static inline int ntp_synced(void)
  */
 
 /*
- * Update (timekeeper.ntp.tick_length, timekeeper.ntp.tick_length_base, timekeeper.ntp.tick_nsec),
- * based on (timekeeper.ntp.tick_usec, timekeeper.ntp.ntp_tick_adj, timekeeper.ntp.time_freq):
+ * Update (ntp->tick_length, ntp->tick_length_base, ntp->tick_nsec),
+ * based on (ntp->tick_usec, ntp->ntp_tick_adj, ntp->time_freq):
  */
-static void ntp_update_frequency(void)
+static void ntp_update_frequency(struct timekeeper_ntp *ntp)
 {
 	u64 second_length;
 	u64 new_base;
 
-	second_length = (u64)(timekeeper.ntp.tick_usec * NSEC_PER_USEC * USER_HZ)
+	second_length = (u64)(ntp->tick_usec * NSEC_PER_USEC * USER_HZ)
 						<< NTP_SCALE_SHIFT;
 
-	second_length += timekeeper.ntp.ntp_tick_adj;
-	second_length += timekeeper.ntp.time_freq;
+	second_length += ntp->ntp_tick_adj;
+	second_length += ntp->time_freq;
 
-	timekeeper.ntp.tick_nsec = div_u64(second_length, HZ) >> NTP_SCALE_SHIFT;
+	ntp->tick_nsec = div_u64(second_length, HZ) >> NTP_SCALE_SHIFT;
 	new_base = div_u64(second_length, NTP_INTERVAL_FREQ);
 
 	/*
 	 * Don't wait for the next second_overflow, apply
 	 * the change to the tick length immediately:
 	 */
-	timekeeper.ntp.tick_length += new_base - timekeeper.ntp.tick_length_base;
-	timekeeper.ntp.tick_length_base = new_base;
+	ntp->tick_length += new_base - ntp->tick_length_base;
+	ntp->tick_length_base = new_base;
 }
 
-static inline s64 ntp_update_offset_fll(s64 offset64, long secs)
+static inline s64 ntp_update_offset_fll(struct timekeeper_ntp *ntp,
+		s64 offset64, long secs)
 {
-	timekeeper.ntp.time_status &= ~STA_MODE;
+	ntp->time_status &= ~STA_MODE;
 
 	if (secs < MINSEC)
 		return 0;
 
-	if (!(timekeeper.ntp.time_status & STA_FLL) && (secs <= MAXSEC))
+	if (!(ntp->time_status & STA_FLL) && (secs <= MAXSEC))
 		return 0;
 
-	timekeeper.ntp.time_status |= STA_MODE;
+	ntp->time_status |= STA_MODE;
 
 	return div64_long(offset64 << (NTP_SCALE_SHIFT - SHIFT_FLL), secs);
 }
 
-static void ntp_update_offset(long offset)
+static void ntp_update_offset(struct timekeeper_ntp *ntp, long offset)
 {
 	s64 freq_adj;
 	s64 offset64;
 	long secs;
 
-	if (!(timekeeper.ntp.time_status & STA_PLL))
+	if (!(ntp->time_status & STA_PLL))
 		return;
 
-	if (!(timekeeper.ntp.time_status & STA_NANO))
+	if (!(ntp->time_status & STA_NANO))
 		offset *= NSEC_PER_USEC;
 
 	/*
@@ -234,57 +235,57 @@ static void ntp_update_offset(long offset)
 	 * Select how the frequency is to be controlled
 	 * and in which mode (PLL or FLL).
 	 */
-	secs = get_seconds() - timekeeper.ntp.time_reftime;
-	if (unlikely(timekeeper.ntp.time_status & STA_FREQHOLD))
+	secs = get_seconds() - ntp->time_reftime;
+	if (unlikely(ntp->time_status & STA_FREQHOLD))
 		secs = 0;
 
-	timekeeper.ntp.time_reftime = get_seconds();
+	ntp->time_reftime = get_seconds();
 
 	offset64    = offset;
-	freq_adj    = ntp_update_offset_fll(offset64, secs);
+	freq_adj    = ntp_update_offset_fll(ntp, offset64, secs);
 
 	/*
 	 * Clamp update interval to reduce PLL gain with low
 	 * sampling rate (e.g. intermittent network connection)
 	 * to avoid instability.
 	 */
-	if (unlikely(secs > 1 << (SHIFT_PLL + 1 + timekeeper.ntp.time_constant)))
-		secs = 1 << (SHIFT_PLL + 1 + timekeeper.ntp.time_constant);
+	if (unlikely(secs > 1 << (SHIFT_PLL + 1 + ntp->time_constant)))
+		secs = 1 << (SHIFT_PLL + 1 + ntp->time_constant);
 
 	freq_adj    += (offset64 * secs) <<
-		(NTP_SCALE_SHIFT - 2 * (SHIFT_PLL + 2 + timekeeper.ntp.time_constant));
+		(NTP_SCALE_SHIFT - 2 * (SHIFT_PLL + 2 + ntp->time_constant));
 
-	freq_adj    = min(freq_adj + timekeeper.ntp.time_freq, MAXFREQ_SCALED);
+	freq_adj    = min(freq_adj + ntp->time_freq, MAXFREQ_SCALED);
 
-	timekeeper.ntp.time_freq   = max(freq_adj, -MAXFREQ_SCALED);
+	ntp->time_freq   = max(freq_adj, -MAXFREQ_SCALED);
 
-	timekeeper.ntp.time_offset = div_s64(offset64 << NTP_SCALE_SHIFT,
+	ntp->time_offset = div_s64(offset64 << NTP_SCALE_SHIFT,
 		NTP_INTERVAL_FREQ);
 }
 
 /**
  * ntp_clear - Clears the NTP state variables
  */
-void ntp_clear(void)
+void ntp_clear(struct timekeeper_ntp *ntp)
 {
-	timekeeper.ntp.time_adjust	= 0;		/* stop active adjtime() */
-	timekeeper.ntp.time_status	|= STA_UNSYNC;
-	timekeeper.ntp.time_maxerror	= NTP_PHASE_LIMIT;
-	timekeeper.ntp.time_esterror	= NTP_PHASE_LIMIT;
+	ntp->time_adjust	= 0;		/* stop active adjtime() */
+	ntp->time_status	|= STA_UNSYNC;
+	ntp->time_maxerror	= NTP_PHASE_LIMIT;
+	ntp->time_esterror	= NTP_PHASE_LIMIT;
 
-	ntp_update_frequency();
+	ntp_update_frequency(ntp);
 
-	timekeeper.ntp.tick_length	= timekeeper.ntp.tick_length_base;
-	timekeeper.ntp.time_offset	= 0;
+	ntp->tick_length	= ntp->tick_length_base;
+	ntp->time_offset	= 0;
 
 	/* Clear PPS state variables */
-	pps_clear();
+	pps_clear(ntp);
 }
 
 
-u64 ntp_tick_length(void)
+u64 ntp_tick_length(struct timekeeper_ntp *ntp)
 {
-	return timekeeper.ntp.tick_length;
+	return ntp->tick_length;
 }
 
 
@@ -298,7 +299,7 @@ u64 ntp_tick_length(void)
  *
  * Also handles leap second processing, and returns leap offset
  */
-int second_overflow(unsigned long secs)
+int second_overflow(struct timekeeper_ntp *ntp, unsigned long secs)
 {
 	s64 delta;
 	int leap = 0;
@@ -308,80 +309,80 @@ int second_overflow(unsigned long secs)
 	 * day, the system clock is set back one second; if in leap-delete
 	 * state, the system clock is set ahead one second.
 	 */
-	switch (timekeeper.ntp.time_state) {
+	switch (ntp->time_state) {
 	case TIME_OK:
-		if (timekeeper.ntp.time_status & STA_INS)
-			timekeeper.ntp.time_state = TIME_INS;
-		else if (timekeeper.ntp.time_status & STA_DEL)
-			timekeeper.ntp.time_state = TIME_DEL;
+		if (ntp->time_status & STA_INS)
+			ntp->time_state = TIME_INS;
+		else if (ntp->time_status & STA_DEL)
+			ntp->time_state = TIME_DEL;
 		break;
 	case TIME_INS:
-		if (!(timekeeper.ntp.time_status & STA_INS))
-			timekeeper.ntp.time_state = TIME_OK;
+		if (!(ntp->time_status & STA_INS))
+			ntp->time_state = TIME_OK;
 		else if (secs % 86400 == 0) {
 			leap = -1;
-			timekeeper.ntp.time_state = TIME_OOP;
+			ntp->time_state = TIME_OOP;
 			printk(KERN_NOTICE
 				"Clock: inserting leap second 23:59:60 UTC\n");
 		}
 		break;
 	case TIME_DEL:
-		if (!(timekeeper.ntp.time_status & STA_DEL))
-			timekeeper.ntp.time_state = TIME_OK;
+		if (!(ntp->time_status & STA_DEL))
+			ntp->time_state = TIME_OK;
 		else if ((secs + 1) % 86400 == 0) {
 			leap = 1;
-			timekeeper.ntp.time_state = TIME_WAIT;
+			ntp->time_state = TIME_WAIT;
 			printk(KERN_NOTICE
 				"Clock: deleting leap second 23:59:59 UTC\n");
 		}
 		break;
 	case TIME_OOP:
-		timekeeper.ntp.time_state = TIME_WAIT;
+		ntp->time_state = TIME_WAIT;
 		break;
 
 	case TIME_WAIT:
-		if (!(timekeeper.ntp.time_status & (STA_INS | STA_DEL)))
-			timekeeper.ntp.time_state = TIME_OK;
+		if (!(ntp->time_status & (STA_INS | STA_DEL)))
+			ntp->time_state = TIME_OK;
 		break;
 	}
 
 
 	/* Bump the maxerror field */
-	timekeeper.ntp.time_maxerror += MAXFREQ / NSEC_PER_USEC;
-	if (timekeeper.ntp.time_maxerror > NTP_PHASE_LIMIT) {
-		timekeeper.ntp.time_maxerror = NTP_PHASE_LIMIT;
-		timekeeper.ntp.time_status |= STA_UNSYNC;
+	ntp->time_maxerror += MAXFREQ / NSEC_PER_USEC;
+	if (ntp->time_maxerror > NTP_PHASE_LIMIT) {
+		ntp->time_maxerror = NTP_PHASE_LIMIT;
+		ntp->time_status |= STA_UNSYNC;
 	}
 
 	/* Compute the phase adjustment for the next second */
-	timekeeper.ntp.tick_length = timekeeper.ntp.tick_length_base;
+	ntp->tick_length = ntp->tick_length_base;
 
-	delta = ntp_offset_chunk(timekeeper.ntp.time_offset);
-	timekeeper.ntp.time_offset -= delta;
-	timekeeper.ntp.tick_length += delta;
+	delta = ntp_offset_chunk(ntp, ntp->time_offset);
+	ntp->time_offset -= delta;
+	ntp->tick_length += delta;
 
 	/* Check PPS signal */
-	pps_dec_valid();
+	pps_dec_valid(ntp);
 
-	if (!timekeeper.ntp.time_adjust)
+	if (!ntp->time_adjust)
 		goto out;
 
-	if (timekeeper.ntp.time_adjust > MAX_TICKADJ) {
-		timekeeper.ntp.time_adjust -= MAX_TICKADJ;
-		timekeeper.ntp.tick_length += MAX_TICKADJ_SCALED;
+	if (ntp->time_adjust > MAX_TICKADJ) {
+		ntp->time_adjust -= MAX_TICKADJ;
+		ntp->tick_length += MAX_TICKADJ_SCALED;
 		goto out;
 	}
 
-	if (timekeeper.ntp.time_adjust < -MAX_TICKADJ) {
-		timekeeper.ntp.time_adjust += MAX_TICKADJ;
-		timekeeper.ntp.tick_length -= MAX_TICKADJ_SCALED;
+	if (ntp->time_adjust < -MAX_TICKADJ) {
+		ntp->time_adjust += MAX_TICKADJ;
+		ntp->tick_length -= MAX_TICKADJ_SCALED;
 		goto out;
 	}
 
-	timekeeper.ntp.tick_length +=
-		(s64)(timekeeper.ntp.time_adjust * NSEC_PER_USEC / NTP_INTERVAL_FREQ)
+	ntp->tick_length +=
+		(s64)(ntp->time_adjust * NSEC_PER_USEC / NTP_INTERVAL_FREQ)
 							 << NTP_SCALE_SHIFT;
-	timekeeper.ntp.time_adjust = 0;
+	ntp->time_adjust = 0;
 
 out:
 	return leap;
@@ -394,6 +395,7 @@ static DECLARE_DELAYED_WORK(sync_cmos_work, sync_cmos_clock);
 
 static void sync_cmos_clock(struct work_struct *work)
 {
+	struct timekeeper_ntp *ntp = &timekeeper.ntp;
 	struct timespec now, next;
 	int fail = 1;
 
@@ -404,7 +406,7 @@ static void sync_cmos_clock(struct work_struct *work)
 	 * 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()) {
+	if (!ntp_synced(ntp)) {
 		/*
 		 * Not synced, exit, do not restart a timer (if one is
 		 * running, let it run out).
@@ -413,7 +415,7 @@ static void sync_cmos_clock(struct work_struct *work)
 	}
 
 	getnstimeofday(&now);
-	if (abs(now.tv_nsec - (NSEC_PER_SEC / 2)) <= timekeeper.ntp.tick_nsec / 2) {
+	if (abs(now.tv_nsec - (NSEC_PER_SEC / 2)) <= ntp->tick_nsec / 2) {
 		struct timespec adjust = now;
 
 		fail = -ENODEV;
@@ -457,74 +459,76 @@ void ntp_notify_cmos_timer(void) { }
 /*
  * Propagate a new txc->status value into the NTP state:
  */
-static inline void process_adj_status(struct timex *txc, struct timespec *ts)
+static inline void process_adj_status(struct timekeeper_ntp *ntp,
+		struct timex *txc, struct timespec *ts)
 {
-	if ((timekeeper.ntp.time_status & STA_PLL) && !(txc->status & STA_PLL)) {
-		timekeeper.ntp.time_state = TIME_OK;
-		timekeeper.ntp.time_status = STA_UNSYNC;
+	if ((ntp->time_status & STA_PLL) && !(txc->status & STA_PLL)) {
+		ntp->time_state = TIME_OK;
+		ntp->time_status = STA_UNSYNC;
 		/* restart PPS frequency calibration */
-		pps_reset_freq_interval();
+		pps_reset_freq_interval(ntp);
 	}
 
 	/*
 	 * If we turn on PLL adjustments then reset the
 	 * reference time to current time.
 	 */
-	if (!(timekeeper.ntp.time_status & STA_PLL) && (txc->status & STA_PLL))
-		timekeeper.ntp.time_reftime = get_seconds();
+	if (!(ntp->time_status & STA_PLL) && (txc->status & STA_PLL))
+		ntp->time_reftime = get_seconds();
 
 	/* only set allowed bits */
-	timekeeper.ntp.time_status &= STA_RONLY;
-	timekeeper.ntp.time_status |= txc->status & ~STA_RONLY;
+	ntp->time_status &= STA_RONLY;
+	ntp->time_status |= txc->status & ~STA_RONLY;
 }
 
 
-static inline void process_adjtimex_modes(struct timex *txc,
+static inline void process_adjtimex_modes(struct timekeeper_ntp *ntp,
+						struct timex *txc,
 						struct timespec *ts,
 						s32 *time_tai)
 {
 	if (txc->modes & ADJ_STATUS)
-		process_adj_status(txc, ts);
+		process_adj_status(ntp, txc, ts);
 
 	if (txc->modes & ADJ_NANO)
-		timekeeper.ntp.time_status |= STA_NANO;
+		ntp->time_status |= STA_NANO;
 
 	if (txc->modes & ADJ_MICRO)
-		timekeeper.ntp.time_status &= ~STA_NANO;
+		ntp->time_status &= ~STA_NANO;
 
 	if (txc->modes & ADJ_FREQUENCY) {
-		timekeeper.ntp.time_freq = txc->freq * PPM_SCALE;
-		timekeeper.ntp.time_freq = min(timekeeper.ntp.time_freq, MAXFREQ_SCALED);
-		timekeeper.ntp.time_freq = max(timekeeper.ntp.time_freq, -MAXFREQ_SCALED);
-		/* update timekeeper.ntp.pps.freq */
-		pps_set_freq(timekeeper.ntp.time_freq);
+		ntp->time_freq = txc->freq * PPM_SCALE;
+		ntp->time_freq = min(ntp->time_freq, MAXFREQ_SCALED);
+		ntp->time_freq = max(ntp->time_freq, -MAXFREQ_SCALED);
+		/* update ntp->pps.freq */
+		pps_set_freq(ntp, ntp->time_freq);
 	}
 
 	if (txc->modes & ADJ_MAXERROR)
-		timekeeper.ntp.time_maxerror = txc->maxerror;
+		ntp->time_maxerror = txc->maxerror;
 
 	if (txc->modes & ADJ_ESTERROR)
-		timekeeper.ntp.time_esterror = txc->esterror;
+		ntp->time_esterror = txc->esterror;
 
 	if (txc->modes & ADJ_TIMECONST) {
-		timekeeper.ntp.time_constant = txc->constant;
-		if (!(timekeeper.ntp.time_status & STA_NANO))
-			timekeeper.ntp.time_constant += 4;
-		timekeeper.ntp.time_constant = min(timekeeper.ntp.time_constant, (long)MAXTC);
-		timekeeper.ntp.time_constant = max(timekeeper.ntp.time_constant, 0l);
+		ntp->time_constant = txc->constant;
+		if (!(ntp->time_status & STA_NANO))
+			ntp->time_constant += 4;
+		ntp->time_constant = min(ntp->time_constant, (long)MAXTC);
+		ntp->time_constant = max(ntp->time_constant, 0l);
 	}
 
 	if (txc->modes & ADJ_TAI && txc->constant > 0)
 		*time_tai = txc->constant;
 
 	if (txc->modes & ADJ_OFFSET)
-		ntp_update_offset(txc->offset);
+		ntp_update_offset(ntp, txc->offset);
 
 	if (txc->modes & ADJ_TICK)
-		timekeeper.ntp.tick_usec = txc->tick;
+		ntp->tick_usec = txc->tick;
 
 	if (txc->modes & (ADJ_TICK|ADJ_FREQUENCY|ADJ_OFFSET))
-		ntp_update_frequency();
+		ntp_update_frequency(ntp);
 }
 
 
@@ -566,54 +570,55 @@ int ntp_validate_timex(struct timex *txc)
  * adjtimex mainly allows reading (and writing, if superuser) of
  * kernel time-keeping variables. used by xntpd.
  */
-int __do_adjtimex(struct timex *txc, struct timespec *ts, s32 *time_tai)
+int __do_adjtimex(struct timekeeper_ntp *ntp, struct timex *txc,
+		struct timespec *ts, s32 *time_tai)
 {
 	int result;
 
 	if (txc->modes & ADJ_ADJTIME) {
-		long save_adjust = timekeeper.ntp.time_adjust;
+		long save_adjust = ntp->time_adjust;
 
 		if (!(txc->modes & ADJ_OFFSET_READONLY)) {
 			/* adjtime() is independent from ntp_adjtime() */
-			timekeeper.ntp.time_adjust = txc->offset;
-			ntp_update_frequency();
+			ntp->time_adjust = txc->offset;
+			ntp_update_frequency(ntp);
 		}
 		txc->offset = save_adjust;
 	} else {
 
 		/* If there are input parameters, then process them: */
 		if (txc->modes)
-			process_adjtimex_modes(txc, ts, time_tai);
+			process_adjtimex_modes(ntp, txc, ts, time_tai);
 
 		txc->offset =
-			shift_right(timekeeper.ntp.time_offset * NTP_INTERVAL_FREQ,
+			shift_right(ntp->time_offset * NTP_INTERVAL_FREQ,
 				  NTP_SCALE_SHIFT);
-		if (!(timekeeper.ntp.time_status & STA_NANO))
+		if (!(ntp->time_status & STA_NANO))
 			txc->offset /= NSEC_PER_USEC;
 	}
 
-	result = timekeeper.ntp.time_state;	/* mostly `TIME_OK' */
+	result = ntp->time_state;	/* mostly `TIME_OK' */
 	/* check for errors */
-	if (is_error_status(timekeeper.ntp.time_status))
+	if (is_error_status(ntp, ntp->time_status))
 		result = TIME_ERROR;
 
-	txc->freq = shift_right((timekeeper.ntp.time_freq >> PPM_SCALE_INV_SHIFT) *
+	txc->freq = shift_right((ntp->time_freq >> PPM_SCALE_INV_SHIFT) *
 		PPM_SCALE_INV, NTP_SCALE_SHIFT);
-	txc->maxerror = timekeeper.ntp.time_maxerror;
-	txc->esterror = timekeeper.ntp.time_esterror;
-	txc->status = timekeeper.ntp.time_status;
-	txc->constant = timekeeper.ntp.time_constant;
+	txc->maxerror = ntp->time_maxerror;
+	txc->esterror = ntp->time_esterror;
+	txc->status = ntp->time_status;
+	txc->constant = ntp->time_constant;
 	txc->precision = 1;
 	txc->tolerance = MAXFREQ_SCALED / PPM_SCALE;
-	txc->tick = timekeeper.ntp.tick_usec;
+	txc->tick = ntp->tick_usec;
 	txc->tai = *time_tai;
 
 	/* fill PPS status fields */
-	pps_fill_timex(txc);
+	pps_fill_timex(ntp, txc);
 
 	txc->time.tv_sec = ts->tv_sec;
 	txc->time.tv_usec = ts->tv_nsec;
-	if (!(timekeeper.ntp.time_status & STA_NANO))
+	if (!(ntp->time_status & STA_NANO))
 		txc->time.tv_usec /= NSEC_PER_USEC;
 
 	return result;
@@ -648,34 +653,35 @@ static inline struct pps_normtime pps_normalize_ts(struct timespec ts)
 }
 
 /* get current phase correction and jitter */
-static inline long pps_phase_filter_get(long *jitter)
+static inline long pps_phase_filter_get(struct timekeeper_ntp *ntp,
+		long *jitter)
 {
-	*jitter = timekeeper.ntp.pps.tf[0] - timekeeper.ntp.pps.tf[1];
+	*jitter = ntp->pps.tf[0] - ntp->pps.tf[1];
 	if (*jitter < 0)
 		*jitter = -*jitter;
 
 	/* TODO: test various filters */
-	return timekeeper.ntp.pps.tf[0];
+	return ntp->pps.tf[0];
 }
 
 /* add the sample to the phase filter */
-static inline void pps_phase_filter_add(long err)
+static inline void pps_phase_filter_add(struct timekeeper_ntp *ntp, long err)
 {
-	timekeeper.ntp.pps.tf[2] = timekeeper.ntp.pps.tf[1];
-	timekeeper.ntp.pps.tf[1] = timekeeper.ntp.pps.tf[0];
-	timekeeper.ntp.pps.tf[0] = err;
+	ntp->pps.tf[2] = ntp->pps.tf[1];
+	ntp->pps.tf[1] = ntp->pps.tf[0];
+	ntp->pps.tf[0] = err;
 }
 
 /* decrease frequency calibration interval length.
  * It is halved after four consecutive unstable intervals.
  */
-static inline void pps_dec_freq_interval(void)
+static inline void pps_dec_freq_interval(struct timekeeper_ntp *ntp)
 {
-	if (--timekeeper.ntp.pps.intcnt <= -PPS_INTCOUNT) {
-		timekeeper.ntp.pps.intcnt = -PPS_INTCOUNT;
-		if (timekeeper.ntp.pps.shift > PPS_INTMIN) {
-			timekeeper.ntp.pps.shift--;
-			timekeeper.ntp.pps.intcnt = 0;
+	if (--ntp->pps.intcnt <= -PPS_INTCOUNT) {
+		ntp->pps.intcnt = -PPS_INTCOUNT;
+		if (ntp->pps.shift > PPS_INTMIN) {
+			ntp->pps.shift--;
+			ntp->pps.intcnt = 0;
 		}
 	}
 }
@@ -683,13 +689,13 @@ static inline void pps_dec_freq_interval(void)
 /* increase frequency calibration interval length.
  * It is doubled after four consecutive stable intervals.
  */
-static inline void pps_inc_freq_interval(void)
+static inline void pps_inc_freq_interval(struct timekeeper_ntp *ntp)
 {
-	if (++timekeeper.ntp.pps.intcnt >= PPS_INTCOUNT) {
-		timekeeper.ntp.pps.intcnt = PPS_INTCOUNT;
-		if (timekeeper.ntp.pps.shift < PPS_INTMAX) {
-			timekeeper.ntp.pps.shift++;
-			timekeeper.ntp.pps.intcnt = 0;
+	if (++ntp->pps.intcnt >= PPS_INTCOUNT) {
+		ntp->pps.intcnt = PPS_INTCOUNT;
+		if (ntp->pps.shift < PPS_INTMAX) {
+			ntp->pps.shift++;
+			ntp->pps.intcnt = 0;
 		}
 	}
 }
@@ -703,16 +709,17 @@ static inline void pps_inc_freq_interval(void)
  * too long, the data are discarded.
  * Returns the difference between old and new frequency values.
  */
-static long hardpps_update_freq(struct pps_normtime freq_norm)
+static long hardpps_update_freq(struct timekeeper_ntp *ntp,
+		struct pps_normtime freq_norm)
 {
 	long delta, delta_mod;
 	s64 ftemp;
 
 	/* check if the frequency interval was too long */
-	if (freq_norm.sec > (2 << timekeeper.ntp.pps.shift)) {
-		timekeeper.ntp.time_status |= STA_PPSERROR;
-		timekeeper.ntp.pps.errcnt++;
-		pps_dec_freq_interval();
+	if (freq_norm.sec > (2 << ntp->pps.shift)) {
+		ntp->time_status |= STA_PPSERROR;
+		ntp->pps.errcnt++;
+		pps_dec_freq_interval(ntp);
 		pr_err("hardpps: PPSERROR: interval too long - %ld s\n",
 				freq_norm.sec);
 		return 0;
@@ -724,15 +731,15 @@ static long hardpps_update_freq(struct pps_normtime freq_norm)
 	 */
 	ftemp = div_s64(((s64)(-freq_norm.nsec)) << NTP_SCALE_SHIFT,
 			freq_norm.sec);
-	delta = shift_right(ftemp - timekeeper.ntp.pps.freq, NTP_SCALE_SHIFT);
-	timekeeper.ntp.pps.freq = ftemp;
+	delta = shift_right(ftemp - ntp->pps.freq, NTP_SCALE_SHIFT);
+	ntp->pps.freq = ftemp;
 	if (delta > PPS_MAXWANDER || delta < -PPS_MAXWANDER) {
 		pr_warning("hardpps: PPSWANDER: change=%ld\n", delta);
-		timekeeper.ntp.time_status |= STA_PPSWANDER;
-		timekeeper.ntp.pps.stbcnt++;
-		pps_dec_freq_interval();
+		ntp->time_status |= STA_PPSWANDER;
+		ntp->pps.stbcnt++;
+		pps_dec_freq_interval(ntp);
 	} else {	/* good sample */
-		pps_inc_freq_interval();
+		pps_inc_freq_interval(ntp);
 	}
 
 	/* the stability metric is calculated as the average of recent
@@ -742,49 +749,49 @@ static long hardpps_update_freq(struct pps_normtime freq_norm)
 	delta_mod = delta;
 	if (delta_mod < 0)
 		delta_mod = -delta_mod;
-	timekeeper.ntp.pps.stabil += (div_s64(((s64)delta_mod) <<
+	ntp->pps.stabil += (div_s64(((s64)delta_mod) <<
 		(NTP_SCALE_SHIFT - SHIFT_USEC),
-		NSEC_PER_USEC) - timekeeper.ntp.pps.stabil) >> PPS_INTMIN;
+		NSEC_PER_USEC) - ntp->pps.stabil) >> PPS_INTMIN;
 
 	/* if enabled, the system clock frequency is updated */
-	if ((timekeeper.ntp.time_status & STA_PPSFREQ) != 0 &&
-	    (timekeeper.ntp.time_status & STA_FREQHOLD) == 0) {
-		timekeeper.ntp.time_freq = timekeeper.ntp.pps.freq;
-		ntp_update_frequency();
+	if ((ntp->time_status & STA_PPSFREQ) != 0 &&
+	    (ntp->time_status & STA_FREQHOLD) == 0) {
+		ntp->time_freq = ntp->pps.freq;
+		ntp_update_frequency(ntp);
 	}
 
 	return delta;
 }
 
 /* correct REALTIME clock phase error against PPS signal */
-static void hardpps_update_phase(long error)
+static void hardpps_update_phase(struct timekeeper_ntp *ntp, long error)
 {
 	long correction = -error;
 	long jitter;
 
 	/* add the sample to the median filter */
-	pps_phase_filter_add(correction);
-	correction = pps_phase_filter_get(&jitter);
+	pps_phase_filter_add(ntp, correction);
+	correction = pps_phase_filter_get(ntp, &jitter);
 
 	/* Nominal jitter is due to PPS signal noise. If it exceeds the
 	 * threshold, the sample is discarded; otherwise, if so enabled,
 	 * the time offset is updated.
 	 */
-	if (jitter > (timekeeper.ntp.pps.jitter << PPS_POPCORN)) {
+	if (jitter > (ntp->pps.jitter << PPS_POPCORN)) {
 		pr_warning("hardpps: PPSJITTER: jitter=%ld, limit=%ld\n",
-		       jitter, (timekeeper.ntp.pps.jitter << PPS_POPCORN));
-		timekeeper.ntp.time_status |= STA_PPSJITTER;
-		timekeeper.ntp.pps.jitcnt++;
-	} else if (timekeeper.ntp.time_status & STA_PPSTIME) {
+		       jitter, (ntp->pps.jitter << PPS_POPCORN));
+		ntp->time_status |= STA_PPSJITTER;
+		ntp->pps.jitcnt++;
+	} else if (ntp->time_status & STA_PPSTIME) {
 		/* correct the time using the phase offset */
-		timekeeper.ntp.time_offset =
+		ntp->time_offset =
 			div_s64(((s64)correction) << NTP_SCALE_SHIFT,
 				NTP_INTERVAL_FREQ);
 		/* cancel running adjtime() */
-		timekeeper.ntp.time_adjust = 0;
+		ntp->time_adjust = 0;
 	}
 	/* update jitter */
-	timekeeper.ntp.pps.jitter += (jitter - timekeeper.ntp.pps.jitter) >> PPS_INTMIN;
+	ntp->pps.jitter += (jitter - ntp->pps.jitter) >> PPS_INTMIN;
 }
 
 /*
@@ -799,38 +806,39 @@ static void hardpps_update_phase(long error)
  * This code is based on David Mills's reference nanokernel
  * implementation. It was mostly rewritten but keeps the same idea.
  */
-void __hardpps(const struct timespec *phase_ts, const struct timespec *raw_ts)
+void __hardpps(struct timekeeper_ntp *ntp, const struct timespec *phase_ts,
+		const struct timespec *raw_ts)
 {
 	struct pps_normtime pts_norm, freq_norm;
 
 	pts_norm = pps_normalize_ts(*phase_ts);
 
 	/* clear the error bits, they will be set again if needed */
-	timekeeper.ntp.time_status &= ~(STA_PPSJITTER | STA_PPSWANDER | STA_PPSERROR);
+	ntp->time_status &= ~(STA_PPSJITTER | STA_PPSWANDER | STA_PPSERROR);
 
 	/* indicate signal presence */
-	timekeeper.ntp.time_status |= STA_PPSSIGNAL;
-	timekeeper.ntp.pps.valid = PPS_VALID;
+	ntp->time_status |= STA_PPSSIGNAL;
+	ntp->pps.valid = PPS_VALID;
 
 	/* when called for the first time,
 	 * just start the frequency interval */
-	if (unlikely(timekeeper.ntp.pps.fbase.tv_sec == 0)) {
-		timekeeper.ntp.pps.fbase = *raw_ts;
+	if (unlikely(ntp->pps.fbase.tv_sec == 0)) {
+		ntp->pps.fbase = *raw_ts;
 		return;
 	}
 
 	/* ok, now we have a base for frequency calculation */
 	freq_norm = pps_normalize_ts(timespec_sub(*raw_ts,
-		timekeeper.ntp.pps.fbase));
+		ntp->pps.fbase));
 
 	/* check that the signal is in the range
 	 * [1s - MAXFREQ us, 1s + MAXFREQ us], otherwise reject it */
 	if ((freq_norm.sec == 0) ||
 			(freq_norm.nsec > MAXFREQ * freq_norm.sec) ||
 			(freq_norm.nsec < -MAXFREQ * freq_norm.sec)) {
-		timekeeper.ntp.time_status |= STA_PPSJITTER;
+		ntp->time_status |= STA_PPSJITTER;
 		/* restart the frequency calibration interval */
-		timekeeper.ntp.pps.fbase = *raw_ts;
+		ntp->pps.fbase = *raw_ts;
 		pr_err("hardpps: PPSJITTER: bad pulse\n");
 		return;
 	}
@@ -838,29 +846,31 @@ void __hardpps(const struct timespec *phase_ts, const struct timespec *raw_ts)
 	/* signal is ok */
 
 	/* check if the current frequency interval is finished */
-	if (freq_norm.sec >= (1 << timekeeper.ntp.pps.shift)) {
-		timekeeper.ntp.pps.calcnt++;
+	if (freq_norm.sec >= (1 << ntp->pps.shift)) {
+		ntp->pps.calcnt++;
 		/* restart the frequency calibration interval */
-		timekeeper.ntp.pps.fbase = *raw_ts;
-		hardpps_update_freq(freq_norm);
+		ntp->pps.fbase = *raw_ts;
+		hardpps_update_freq(ntp, freq_norm);
 	}
 
-	hardpps_update_phase(pts_norm.nsec);
+	hardpps_update_phase(ntp, pts_norm.nsec);
 
 }
 #endif	/* CONFIG_NTP_PPS */
 
 static int __init ntp_tick_adj_setup(char *str)
 {
-	timekeeper.ntp.ntp_tick_adj = simple_strtol(str, NULL, 0);
-	timekeeper.ntp.ntp_tick_adj <<= NTP_SCALE_SHIFT;
+	struct timekeeper_ntp *ntp = &timekeeper.ntp;
+
+	ntp->ntp_tick_adj = simple_strtol(str, NULL, 0);
+	ntp->ntp_tick_adj <<= NTP_SCALE_SHIFT;
 
 	return 1;
 }
 
 __setup("ntp_tick_adj=", ntp_tick_adj_setup);
 
-void __init ntp_init(void)
+void __init ntp_init(struct timekeeper_ntp *ntp)
 {
-	ntp_clear();
+	ntp_clear(ntp);
 }
diff --git a/kernel/time/ntp_internal.h b/kernel/time/ntp_internal.h
index 1950cb4..970e260 100644
--- a/kernel/time/ntp_internal.h
+++ b/kernel/time/ntp_internal.h
@@ -1,12 +1,16 @@
 #ifndef _LINUX_NTP_INTERNAL_H
 #define _LINUX_NTP_INTERNAL_H
 
-extern void ntp_init(void);
-extern void ntp_clear(void);
+struct timekeeper_ntp;
+
+extern void ntp_init(struct timekeeper_ntp *ntp);
+extern void ntp_clear(struct timekeeper_ntp *ntp);
 /* Returns how long ticks are at present, in ns / 2^NTP_SCALE_SHIFT. */
-extern u64 ntp_tick_length(void);
-extern int second_overflow(unsigned long secs);
+extern u64 ntp_tick_length(struct timekeeper_ntp *ntp);
+extern int second_overflow(struct timekeeper_ntp *ntp, unsigned long secs);
 extern int ntp_validate_timex(struct timex *);
-extern int __do_adjtimex(struct timex *, struct timespec *, s32 *);
-extern void __hardpps(const struct timespec *, const struct timespec *);
+extern int __do_adjtimex(struct timekeeper_ntp *ntp, struct timex *,
+		struct timespec *, s32 *);
+extern void __hardpps(struct timekeeper_ntp *ntp, const struct timespec *,
+		const struct timespec *);
 #endif /* _LINUX_NTP_INTERNAL_H */
diff --git a/kernel/time/timekeeping.c b/kernel/time/timekeeping.c
index d1ecafb..2210abb 100644
--- a/kernel/time/timekeeping.c
+++ b/kernel/time/timekeeping.c
@@ -260,7 +260,7 @@ static void timekeeping_update(struct timekeeper *tk, unsigned int action)
 {
 	if (action & TK_CLEAR_NTP) {
 		tk->ntp_error = 0;
-		ntp_clear();
+		ntp_clear(&tk->ntp);
 	}
 	update_vsyscall(tk);
 	update_pvclock_gtod(tk, action & TK_CLOCK_WAS_SET);
@@ -819,7 +819,7 @@ void __init timekeeping_init(void)
 
 	raw_spin_lock_irqsave(&timekeeper_lock, flags);
 	write_seqcount_begin(&timekeeper_seq);
-	ntp_init();
+	ntp_init(&tk->ntp);
 
 	clock = clocksource_default_clock();
 	if (clock->enable)
@@ -1087,7 +1087,7 @@ static __always_inline int timekeeping_bigadjust(struct timekeeper *tk,
 	 * Now calculate the error in (1 << look_ahead) ticks, but first
 	 * remove the single look ahead already included in the error.
 	 */
-	tick_error = ntp_tick_length() >> (tk->ntp_error_shift + 1);
+	tick_error = ntp_tick_length(&tk->ntp) >> (tk->ntp_error_shift + 1);
 	tick_error -= tk->xtime_interval >> 1;
 	error = ((error - tick_error) >> look_ahead) + tick_error;
 
@@ -1274,7 +1274,7 @@ static inline unsigned int accumulate_nsecs_to_secs(struct timekeeper *tk)
 		tk->xtime_sec++;
 
 		/* Figure out if its a leap sec and apply if needed */
-		leap = second_overflow(tk->xtime_sec);
+		leap = second_overflow(&tk->ntp, tk->xtime_sec);
 		if (unlikely(leap)) {
 			struct timespec ts;
 
@@ -1331,7 +1331,7 @@ static cycle_t logarithmic_accumulation(struct timekeeper *tk, cycle_t offset,
 	tk->raw_time.tv_nsec = raw_nsecs;
 
 	/* Accumulate error between NTP and clock interval */
-	tk->ntp_error += ntp_tick_length() << shift;
+	tk->ntp_error += ntp_tick_length(&tk->ntp) << shift;
 	tk->ntp_error -= (tk->xtime_interval + tk->xtime_remainder) <<
 						(tk->ntp_error_shift + shift);
 
@@ -1408,7 +1408,7 @@ static void update_wall_time(void)
 	shift = ilog2(offset) - ilog2(tk->cycle_interval);
 	shift = max(0, shift);
 	/* Bound shift to one less than what overflows tick_length */
-	maxshift = (64 - (ilog2(ntp_tick_length())+1)) - 1;
+	maxshift = (64 - (ilog2(ntp_tick_length(&tk->ntp))+1)) - 1;
 	shift = min(shift, maxshift);
 	while (offset >= tk->cycle_interval) {
 		offset = logarithmic_accumulation(tk, offset, shift);
@@ -1703,7 +1703,7 @@ int do_adjtimex(struct timex *txc)
 	write_seqcount_begin(&timekeeper_seq);
 
 	orig_tai = tai = tk->tai_offset;
-	ret = __do_adjtimex(txc, &ts, &tai);
+	ret = __do_adjtimex(&tk->ntp, txc, &ts, &tai);
 
 	if (tai != orig_tai) {
 		__timekeeping_set_tai_offset(tk, tai);
@@ -1724,12 +1724,13 @@ int do_adjtimex(struct timex *txc)
  */
 void hardpps(const struct timespec *phase_ts, const struct timespec *raw_ts)
 {
+	struct timekeeper *tk = &timekeeper;
 	unsigned long flags;
 
 	raw_spin_lock_irqsave(&timekeeper_lock, flags);
 	write_seqcount_begin(&timekeeper_seq);
 
-	__hardpps(phase_ts, raw_ts);
+	__hardpps(&tk->ntp, phase_ts, raw_ts);
 
 	write_seqcount_end(&timekeeper_seq);
 	raw_spin_unlock_irqrestore(&timekeeper_lock, flags);
-- 
1.7.10.4

[PATCH 5/7] clocksource: add latch to clocksource

[Mathieu Desnoyers]

Add latch for data used by clock read operations. This is in preparation
for the clock latch synchronization scheme. "cycle_last" rely on
timekeeper seqlock synchronization, and will therefore need to be
latched.

Add:
- cycle_last_latch (array of 2 elements),
- read_latch(),
- update_latch().

Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Cc: John Stultz <john.stultz@linaro.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Peter Zijlstra <peterz@infradead.org>
---
 include/linux/clocksource.h |    4 ++++
 1 file changed, 4 insertions(+)

diff --git a/include/linux/clocksource.h b/include/linux/clocksource.h
index dbbf8aa..ef9c2e5 100644
--- a/include/linux/clocksource.h
+++ b/include/linux/clocksource.h
@@ -180,6 +180,10 @@ struct clocksource {
 #ifdef CONFIG_ARCH_CLOCKSOURCE_DATA
 	struct arch_clocksource_data archdata;
 #endif
+	cycle_t (*read_latch)(struct clocksource *cs, int index);
+	void (*update_latch)(struct clocksource *cs, int oldindex,
+			int newindex);
+	cycle_t cycle_last_latch[2];
 
 	const char *name;
 	struct list_head list;
-- 
1.7.10.4

[PATCH 6/7] x86 tsc clock: implement clock latch

[Mathieu Desnoyers]

Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Cc: John Stultz <john.stultz@linaro.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Peter Zijlstra <peterz@infradead.org>
---
 arch/x86/kernel/tsc.c |   22 +++++++++++++++++++++-
 1 file changed, 21 insertions(+), 1 deletion(-)

diff --git a/arch/x86/kernel/tsc.c b/arch/x86/kernel/tsc.c
index 6ff4924..c75e9f9 100644
--- a/arch/x86/kernel/tsc.c
+++ b/arch/x86/kernel/tsc.c
@@ -766,10 +766,28 @@ static cycle_t read_tsc(struct clocksource *cs)
 		ret : clocksource_tsc.cycle_last;
 }
 
+static cycle_t read_tsc_latch(struct clocksource *cs, int index)
+{
+	cycle_t ret = (cycle_t)get_cycles();
+
+	return ret >= clocksource_tsc.cycle_last_latch[index] ?
+		ret : clocksource_tsc.cycle_last_latch[index];
+}
+
+static void update_tsc_latch(struct clocksource *cs, int oldindex,
+		int newindex)
+{
+	clocksource_tsc.cycle_last_latch[newindex] =
+		clocksource_tsc.cycle_last_latch[oldindex];
+}
+
 static void resume_tsc(struct clocksource *cs)
 {
-	if (!boot_cpu_has(X86_FEATURE_NONSTOP_TSC_S3))
+	if (!boot_cpu_has(X86_FEATURE_NONSTOP_TSC_S3)) {
 		clocksource_tsc.cycle_last = 0;
+		clocksource_tsc.cycle_last_latch[0] = 0;
+		clocksource_tsc.cycle_last_latch[1] = 0;
+	}
 }
 
 static struct clocksource clocksource_tsc = {
@@ -783,6 +801,8 @@ static struct clocksource clocksource_tsc = {
 #ifdef CONFIG_X86_64
 	.archdata               = { .vclock_mode = VCLOCK_TSC },
 #endif
+	.read_latch		= read_tsc_latch,
+	.update_latch		= update_tsc_latch,
 };
 
 void mark_tsc_unstable(char *reason)
-- 
1.7.10.4

[PATCH 7/7] Introduce timekeeper latch synchronization

[Mathieu Desnoyers]

Unlike the sequence lock, this latch synchronization scheme, proposed by
Peter Zijlstra, always keeps a readable copy of the data. Therefore,
readers will never deadlock if they nest on the writer, whether this
happens because the read-side is explicitly called within the write-side
critical section, executed in a nested interrupt (e.g. NMI), or executed
in an execution context that has lock dependency with the write-side
critical section.

The only situations in which readers have to retry is if 2 updates or
more happen concurrently with the read. Therefore, the only situation
that can trigger a reader retry involves updater progress, therefore if
a reader interrupts an update, it would interrupt progress of every
updates, and therefore the reader never has to retry.

A nice side-effect of this scheme is that the reader latency in the
case readers execute concurrently with updaters should be diminished,
because readers don't have to busy-loop when executing concurrently with
updaters, unless 2 or more updates are performed concurrently with the
read.

The overhead of this scheme is that every update must perform a copy of
struct timekeeper and then modify this copy rather than to do the update
in-place.

There should not be any significant overhead added to the read-side,
given the number of memory barriers is unchanged.

Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Cc: John Stultz <john.stultz@linaro.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Peter Zijlstra <peterz@infradead.org>
---
 include/linux/timekeeper_internal.h |   93 ++++++++-
 kernel/time/ntp.c                   |   20 +-
 kernel/time/timekeeping.c           |  375 ++++++++++++++++++++---------------
 3 files changed, 317 insertions(+), 171 deletions(-)

diff --git a/include/linux/timekeeper_internal.h b/include/linux/timekeeper_internal.h
index 6f0532d..af54571 100644
--- a/include/linux/timekeeper_internal.h
+++ b/include/linux/timekeeper_internal.h
@@ -151,7 +151,98 @@ struct timekeeper {
 	struct timekeeper_ntp	ntp;
 };
 
-extern struct timekeeper timekeeper;
+struct timekeeper_latch {
+	unsigned long head, tail;
+	struct timekeeper data[2];
+};
+
+static inline
+int timekeeper_index(struct timekeeper_latch *tl, const struct timekeeper *tk)
+{
+	return tk - &tl->data[0];
+}
+
+extern struct timekeeper_latch timekeeper_latch;
+extern raw_spinlock_t timekeeper_lock;
+
+/**
+ * timekeeper_write_begin - begin timekeeper update.
+ *
+ " @tl: struct timekeeper_latch to update.
+ * @next: pointer to next element (output parameter).
+ *
+ * The area pointed to by "next" should be considered uninitialized.
+ * The caller needs to have exclusive update access to struct timekeeper_latch.
+ */
+static inline
+void timekeeper_write_begin(struct timekeeper_latch *tl,
+		struct timekeeper **next)
+{
+	const struct timekeeper *_prev;
+	struct timekeeper *_next;
+
+	tl->head++;
+	smp_wmb();		/* Store head before storing into next entry */
+	_prev = &tl->data[tl->tail & 1];
+	_next = &tl->data[tl->head & 1];
+	*_next = *_prev;	/* Copy prev content into next */
+	if (_next->clock && _next->clock->update_latch)
+		_next->clock->update_latch(_next->clock,
+				timekeeper_index(tl, _prev),
+				timekeeper_index(tl, _next));
+	*next = _next;
+}
+
+/**
+ * timekeeper_write_end - end timekeeper update.
+ *
+ " @tl: struct timekeeper_latch.
+ *
+ * The caller needs to have exclusive update access to struct timekeeper_latch.
+ */
+static inline
+void timekeeper_write_end(struct timekeeper_latch *tl)
+{
+	smp_wmb();	/* Store into next entry before storing into tail */
+	tl->tail++;
+}
+
+/**
+ * timekeeper_read_begin - begin timekeeper read.
+ *
+ " @tl: struct timekeeper_latch to read.
+ * @tail: pointer to unsigned long containing tail position (output).
+ */
+static inline
+struct timekeeper *timekeeper_read_begin(struct timekeeper_latch *tl,
+		unsigned long *tail)
+{
+	unsigned long ret;
+
+	ret = ACCESS_ONCE(tl->tail);
+	smp_rmb();	/* Load tail before loading entry */
+	*tail = ret;
+	return &tl->data[ret & 1];
+}
+
+/**
+ * timekeeper_read_retry - end timekeeper read, trigger retry if needed.
+ *
+ " @tl: struct timekeeper_latch read.
+ * @tail: tail position returned as output by timekeeper_read_begin().
+ *
+ * If timekeeper_read_retry() returns nonzero, the content of the read should
+ * be considered invalid, and the read should be performed again to
+ * reattempt reading coherent data, starting with timekeeper_read_begin().
+ */
+static inline
+int timekeeper_read_retry(struct timekeeper_latch *tl, unsigned long tail)
+{
+	smp_rmb();	/* Load entry before loading head */
+	return (ACCESS_ONCE(tl->head) - tail >= 2);
+}
+
+extern struct timekeeper *timekeeper_get_init(void);
 
 static inline struct timespec tk_xtime(struct timekeeper *tk)
 {
diff --git a/kernel/time/ntp.c b/kernel/time/ntp.c
index 2a1b4ef..71a5d2a 100644
--- a/kernel/time/ntp.c
+++ b/kernel/time/ntp.c
@@ -395,9 +395,10 @@ static DECLARE_DELAYED_WORK(sync_cmos_work, sync_cmos_clock);
 
 static void sync_cmos_clock(struct work_struct *work)
 {
-	struct timekeeper_ntp *ntp = &timekeeper.ntp;
+	struct timekeeper *tk;
+	unsigned long seq, local_tick_nsec;
 	struct timespec now, next;
-	int fail = 1;
+	int fail = 1, ret;
 
 	/*
 	 * If we have an externally synchronized Linux clock, then update
@@ -406,7 +407,11 @@ static void sync_cmos_clock(struct work_struct *work)
 	 * 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(ntp)) {
+	do {
+		tk = timekeeper_read_begin(&timekeeper_latch, &seq);
+		ret = ntp_synced(&tk->ntp);
+	} while (timekeeper_read_retry(&timekeeper_latch, seq));
+	if (!ret) {
 		/*
 		 * Not synced, exit, do not restart a timer (if one is
 		 * running, let it run out).
@@ -415,7 +420,11 @@ static void sync_cmos_clock(struct work_struct *work)
 	}
 
 	getnstimeofday(&now);
-	if (abs(now.tv_nsec - (NSEC_PER_SEC / 2)) <= ntp->tick_nsec / 2) {
+	do {
+		tk = timekeeper_read_begin(&timekeeper_latch, &seq);
+		local_tick_nsec = tk->ntp.tick_nsec;
+	} while (timekeeper_read_retry(&timekeeper_latch, seq));
+	if (abs(now.tv_nsec - (NSEC_PER_SEC / 2)) <= local_tick_nsec / 2) {
 		struct timespec adjust = now;
 
 		fail = -ENODEV;
@@ -860,8 +869,9 @@ void __hardpps(struct timekeeper_ntp *ntp, const struct timespec *phase_ts,
 
 static int __init ntp_tick_adj_setup(char *str)
 {
-	struct timekeeper_ntp *ntp = &timekeeper.ntp;
+	struct timekeeper_ntp *ntp;
 
+	ntp = &timekeeper_get_init()->ntp;
 	ntp->ntp_tick_adj = simple_strtol(str, NULL, 0);
 	ntp->ntp_tick_adj <<= NTP_SCALE_SHIFT;
 
diff --git a/kernel/time/timekeeping.c b/kernel/time/timekeeping.c
index 2210abb..4039691 100644
--- a/kernel/time/timekeeping.c
+++ b/kernel/time/timekeeping.c
@@ -28,23 +28,22 @@
 #include "timekeeping_internal.h"
 
 #define TK_CLEAR_NTP		(1 << 0)
-#define TK_MIRROR		(1 << 1)
-#define TK_CLOCK_WAS_SET	(1 << 2)
-
-struct timekeeper timekeeper = {
-	.ntp = {
-		.tick_usec = TICK_USEC,
-		.time_state = TIME_OK,
-		.time_status = STA_UNSYNC,
-		.time_constant = 2,
-		.time_maxerror = NTP_PHASE_LIMIT,
-		.time_esterror = NTP_PHASE_LIMIT,
+#define TK_CLOCK_WAS_SET	(1 << 1)
+
+struct timekeeper_latch timekeeper_latch = {
+	.data[0] = {
+		.ntp = {
+			.tick_usec = TICK_USEC,
+			.time_state = TIME_OK,
+			.time_status = STA_UNSYNC,
+			.time_constant = 2,
+			.time_maxerror = NTP_PHASE_LIMIT,
+			.time_esterror = NTP_PHASE_LIMIT,
+		},
 	},
 };
 
-static DEFINE_RAW_SPINLOCK(timekeeper_lock);
-static seqcount_t timekeeper_seq;
-static struct timekeeper shadow_timekeeper;
+DEFINE_RAW_SPINLOCK(timekeeper_lock);
 
 /* flag for if timekeeping is suspended */
 int __read_mostly timekeeping_suspended;
@@ -52,6 +51,16 @@ int __read_mostly timekeeping_suspended;
 /* Flag for if there is a persistent clock on this platform */
 bool __read_mostly persistent_clock_exist = false;
 
+/*
+ * timekeeper_get_init - get initial timekeeper structure (boot time init)
+ */
+struct timekeeper *timekeeper_get_init(void)
+{
+	struct timekeeper_latch *tl = &timekeeper_latch;
+
+	return &tl->data[tl->head & 1];
+}
+
 static inline void tk_normalize_xtime(struct timekeeper *tk)
 {
 	while (tk->xtime_nsec >= ((u64)NSEC_PER_SEC << tk->shift)) {
@@ -114,10 +123,13 @@ static void tk_setup_internals(struct timekeeper *tk, struct clocksource *clock)
 	cycle_t interval;
 	u64 tmp, ntpinterval;
 	struct clocksource *old_clock;
+	int tk_index = timekeeper_index(&timekeeper_latch, tk);
 
 	old_clock = tk->clock;
 	tk->clock = clock;
-	tk->cycle_last = clock->cycle_last = clock->read(clock);
+	tk->cycle_last =
+		clock->cycle_last_latch[tk_index] =
+		clock->cycle_last = clock->read(clock);
 
 	/* Do the ns -> cycle conversion first, using original mult */
 	tmp = NTP_INTERVAL_LENGTH;
@@ -178,13 +190,22 @@ static inline s64 timekeeping_get_ns(struct timekeeper *tk)
 	cycle_t cycle_now, cycle_delta;
 	struct clocksource *clock;
 	s64 nsec;
+	int tk_index = timekeeper_index(&timekeeper_latch, tk);
 
 	/* read clocksource: */
 	clock = tk->clock;
-	cycle_now = clock->read(clock);
+	if (clock->read_latch) {
+		cycle_now = clock->read_latch(clock, tk_index);
 
-	/* calculate the delta since the last update_wall_time: */
-	cycle_delta = (cycle_now - clock->cycle_last) & clock->mask;
+		/* calculate the delta since the last update_wall_time: */
+		cycle_delta = (cycle_now -
+			clock->cycle_last_latch[tk_index]) & clock->mask;
+	} else {
+		cycle_now = clock->read(clock);
+
+		/* calculate the delta since the last update_wall_time: */
+		cycle_delta = (cycle_now - clock->cycle_last) & clock->mask;
+	}
 
 	nsec = cycle_delta * tk->mult + tk->xtime_nsec;
 	nsec >>= tk->shift;
@@ -198,13 +219,22 @@ static inline s64 timekeeping_get_ns_raw(struct timekeeper *tk)
 	cycle_t cycle_now, cycle_delta;
 	struct clocksource *clock;
 	s64 nsec;
+	int tk_index = timekeeper_index(&timekeeper_latch, tk);
 
 	/* read clocksource: */
 	clock = tk->clock;
-	cycle_now = clock->read(clock);
+	if (clock->read_latch) {
+		cycle_now = clock->read_latch(clock, tk_index);
 
-	/* calculate the delta since the last update_wall_time: */
-	cycle_delta = (cycle_now - clock->cycle_last) & clock->mask;
+		/* calculate the delta since the last update_wall_time: */
+		cycle_delta = (cycle_now -
+			clock->cycle_last_latch[tk_index]) & clock->mask;
+	} else {
+		cycle_now = clock->read(clock);
+
+		/* calculate the delta since the last update_wall_time: */
+		cycle_delta = (cycle_now - clock->cycle_last) & clock->mask;
+	}
 
 	/* convert delta to nanoseconds. */
 	nsec = clocksource_cyc2ns(cycle_delta, clock->mult, clock->shift);
@@ -225,13 +255,15 @@ static void update_pvclock_gtod(struct timekeeper *tk, bool was_set)
  */
 int pvclock_gtod_register_notifier(struct notifier_block *nb)
 {
-	struct timekeeper *tk = &timekeeper;
+	struct timekeeper *tk;
 	unsigned long flags;
 	int ret;
 
 	raw_spin_lock_irqsave(&timekeeper_lock, flags);
+	timekeeper_write_begin(&timekeeper_latch, &tk);
 	ret = raw_notifier_chain_register(&pvclock_gtod_chain, nb);
 	update_pvclock_gtod(tk, true);
+	timekeeper_write_end(&timekeeper_latch);
 	raw_spin_unlock_irqrestore(&timekeeper_lock, flags);
 
 	return ret;
@@ -264,9 +296,6 @@ static void timekeeping_update(struct timekeeper *tk, unsigned int action)
 	}
 	update_vsyscall(tk);
 	update_pvclock_gtod(tk, action & TK_CLOCK_WAS_SET);
-
-	if (action & TK_MIRROR)
-		memcpy(&shadow_timekeeper, &timekeeper, sizeof(timekeeper));
 }
 
 /**
@@ -281,11 +310,13 @@ static void timekeeping_forward_now(struct timekeeper *tk)
 	cycle_t cycle_now, cycle_delta;
 	struct clocksource *clock;
 	s64 nsec;
+	int tk_index = timekeeper_index(&timekeeper_latch, tk);
 
 	clock = tk->clock;
 	cycle_now = clock->read(clock);
 	cycle_delta = (cycle_now - clock->cycle_last) & clock->mask;
-	tk->cycle_last = clock->cycle_last = cycle_now;
+	tk->cycle_last = clock->cycle_last =
+		clock->cycle_last_latch[tk_index] = cycle_now;
 
 	tk->xtime_nsec += cycle_delta * tk->mult;
 
@@ -307,17 +338,15 @@ static void timekeeping_forward_now(struct timekeeper *tk)
  */
 int __getnstimeofday(struct timespec *ts)
 {
-	struct timekeeper *tk = &timekeeper;
+	struct timekeeper *tk;
 	unsigned long seq;
 	s64 nsecs = 0;
 
 	do {
-		seq = read_seqcount_begin(&timekeeper_seq);
-
+		tk = timekeeper_read_begin(&timekeeper_latch, &seq);
 		ts->tv_sec = tk->xtime_sec;
 		nsecs = timekeeping_get_ns(tk);
-
-	} while (read_seqcount_retry(&timekeeper_seq, seq));
+	} while (timekeeper_read_retry(&timekeeper_latch, seq));
 
 	ts->tv_nsec = 0;
 	timespec_add_ns(ts, nsecs);
@@ -346,18 +375,17 @@ EXPORT_SYMBOL(getnstimeofday);
 
 ktime_t ktime_get(void)
 {
-	struct timekeeper *tk = &timekeeper;
-	unsigned int seq;
+	struct timekeeper *tk;
+	unsigned long seq;
 	s64 secs, nsecs;
 
 	WARN_ON(timekeeping_suspended);
 
 	do {
-		seq = read_seqcount_begin(&timekeeper_seq);
+		tk = timekeeper_read_begin(&timekeeper_latch, &seq);
 		secs = tk->xtime_sec + tk->wall_to_monotonic.tv_sec;
 		nsecs = timekeeping_get_ns(tk) + tk->wall_to_monotonic.tv_nsec;
-
-	} while (read_seqcount_retry(&timekeeper_seq, seq));
+	} while (timekeeper_read_retry(&timekeeper_latch, seq));
 	/*
 	 * Use ktime_set/ktime_add_ns to create a proper ktime on
 	 * 32-bit architectures without CONFIG_KTIME_SCALAR.
@@ -376,20 +404,19 @@ EXPORT_SYMBOL_GPL(ktime_get);
  */
 void ktime_get_ts(struct timespec *ts)
 {
-	struct timekeeper *tk = &timekeeper;
+	struct timekeeper *tk;
 	struct timespec tomono;
 	s64 nsec;
-	unsigned int seq;
+	unsigned long seq;
 
 	WARN_ON(timekeeping_suspended);
 
 	do {
-		seq = read_seqcount_begin(&timekeeper_seq);
+		tk = timekeeper_read_begin(&timekeeper_latch, &seq);
 		ts->tv_sec = tk->xtime_sec;
 		nsec = timekeeping_get_ns(tk);
 		tomono = tk->wall_to_monotonic;
-
-	} while (read_seqcount_retry(&timekeeper_seq, seq));
+	} while (timekeeper_read_retry(&timekeeper_latch, seq));
 
 	ts->tv_sec += tomono.tv_sec;
 	ts->tv_nsec = 0;
@@ -406,19 +433,17 @@ EXPORT_SYMBOL_GPL(ktime_get_ts);
  */
 void timekeeping_clocktai(struct timespec *ts)
 {
-	struct timekeeper *tk = &timekeeper;
+	struct timekeeper *tk;
 	unsigned long seq;
 	u64 nsecs;
 
 	WARN_ON(timekeeping_suspended);
 
 	do {
-		seq = read_seqcount_begin(&timekeeper_seq);
-
+		tk = timekeeper_read_begin(&timekeeper_latch, &seq);
 		ts->tv_sec = tk->xtime_sec + tk->tai_offset;
 		nsecs = timekeeping_get_ns(tk);
-
-	} while (read_seqcount_retry(&timekeeper_seq, seq));
+	} while (timekeeper_read_retry(&timekeeper_latch, seq));
 
 	ts->tv_nsec = 0;
 	timespec_add_ns(ts, nsecs);
@@ -454,14 +479,14 @@ EXPORT_SYMBOL(ktime_get_clocktai);
  */
 void getnstime_raw_and_real(struct timespec *ts_raw, struct timespec *ts_real)
 {
-	struct timekeeper *tk = &timekeeper;
+	struct timekeeper *tk;
 	unsigned long seq;
 	s64 nsecs_raw, nsecs_real;
 
 	WARN_ON_ONCE(timekeeping_suspended);
 
 	do {
-		seq = read_seqcount_begin(&timekeeper_seq);
+		tk = timekeeper_read_begin(&timekeeper_latch, &seq);
 
 		*ts_raw = tk->raw_time;
 		ts_real->tv_sec = tk->xtime_sec;
@@ -470,7 +495,7 @@ void getnstime_raw_and_real(struct timespec *ts_raw, struct timespec *ts_real)
 		nsecs_raw = timekeeping_get_ns_raw(tk);
 		nsecs_real = timekeeping_get_ns(tk);
 
-	} while (read_seqcount_retry(&timekeeper_seq, seq));
+	} while (timekeeper_read_retry(&timekeeper_latch, seq));
 
 	timespec_add_ns(ts_raw, nsecs_raw);
 	timespec_add_ns(ts_real, nsecs_real);
@@ -503,7 +528,7 @@ EXPORT_SYMBOL(do_gettimeofday);
  */
 int do_settimeofday(const struct timespec *tv)
 {
-	struct timekeeper *tk = &timekeeper;
+	struct timekeeper *tk;
 	struct timespec ts_delta, xt;
 	unsigned long flags;
 
@@ -511,7 +536,7 @@ int do_settimeofday(const struct timespec *tv)
 		return -EINVAL;
 
 	raw_spin_lock_irqsave(&timekeeper_lock, flags);
-	write_seqcount_begin(&timekeeper_seq);
+	timekeeper_write_begin(&timekeeper_latch, &tk);
 
 	timekeeping_forward_now(tk);
 
@@ -523,9 +548,9 @@ int do_settimeofday(const struct timespec *tv)
 
 	tk_set_xtime(tk, tv);
 
-	timekeeping_update(tk, TK_CLEAR_NTP | TK_MIRROR | TK_CLOCK_WAS_SET);
+	timekeeping_update(tk, TK_CLEAR_NTP | TK_CLOCK_WAS_SET);
 
-	write_seqcount_end(&timekeeper_seq);
+	timekeeper_write_end(&timekeeper_latch);
 	raw_spin_unlock_irqrestore(&timekeeper_lock, flags);
 
 	/* signal hrtimers about time change */
@@ -543,7 +568,7 @@ EXPORT_SYMBOL(do_settimeofday);
  */
 int timekeeping_inject_offset(struct timespec *ts)
 {
-	struct timekeeper *tk = &timekeeper;
+	struct timekeeper *tk;
 	unsigned long flags;
 	struct timespec tmp;
 	int ret = 0;
@@ -552,7 +577,7 @@ int timekeeping_inject_offset(struct timespec *ts)
 		return -EINVAL;
 
 	raw_spin_lock_irqsave(&timekeeper_lock, flags);
-	write_seqcount_begin(&timekeeper_seq);
+	timekeeper_write_begin(&timekeeper_latch, &tk);
 
 	timekeeping_forward_now(tk);
 
@@ -567,9 +592,9 @@ int timekeeping_inject_offset(struct timespec *ts)
 	tk_set_wall_to_mono(tk, timespec_sub(tk->wall_to_monotonic, *ts));
 
 error: /* even if we error out, we forwarded the time, so call update */
-	timekeeping_update(tk, TK_CLEAR_NTP | TK_MIRROR | TK_CLOCK_WAS_SET);
+	timekeeping_update(tk, TK_CLEAR_NTP | TK_CLOCK_WAS_SET);
 
-	write_seqcount_end(&timekeeper_seq);
+	timekeeper_write_end(&timekeeper_latch);
 	raw_spin_unlock_irqrestore(&timekeeper_lock, flags);
 
 	/* signal hrtimers about time change */
@@ -586,14 +611,14 @@ EXPORT_SYMBOL(timekeeping_inject_offset);
  */
 s32 timekeeping_get_tai_offset(void)
 {
-	struct timekeeper *tk = &timekeeper;
-	unsigned int seq;
+	struct timekeeper *tk;
+	unsigned long seq;
 	s32 ret;
 
 	do {
-		seq = read_seqcount_begin(&timekeeper_seq);
+		tk = timekeeper_read_begin(&timekeeper_latch, &seq);
 		ret = tk->tai_offset;
-	} while (read_seqcount_retry(&timekeeper_seq, seq));
+	} while (timekeeper_read_retry(&timekeeper_latch, seq));
 
 	return ret;
 }
@@ -614,13 +639,13 @@ static void __timekeeping_set_tai_offset(struct timekeeper *tk, s32 tai_offset)
  */
 void timekeeping_set_tai_offset(s32 tai_offset)
 {
-	struct timekeeper *tk = &timekeeper;
+	struct timekeeper *tk;
 	unsigned long flags;
 
 	raw_spin_lock_irqsave(&timekeeper_lock, flags);
-	write_seqcount_begin(&timekeeper_seq);
+	timekeeper_write_begin(&timekeeper_latch, &tk);
 	__timekeeping_set_tai_offset(tk, tai_offset);
-	write_seqcount_end(&timekeeper_seq);
+	timekeeper_write_end(&timekeeper_latch);
 	raw_spin_unlock_irqrestore(&timekeeper_lock, flags);
 	clock_was_set();
 }
@@ -632,14 +657,14 @@ void timekeeping_set_tai_offset(s32 tai_offset)
  */
 static int change_clocksource(void *data)
 {
-	struct timekeeper *tk = &timekeeper;
+	struct timekeeper *tk;
 	struct clocksource *new, *old;
 	unsigned long flags;
 
 	new = (struct clocksource *) data;
 
 	raw_spin_lock_irqsave(&timekeeper_lock, flags);
-	write_seqcount_begin(&timekeeper_seq);
+	timekeeper_write_begin(&timekeeper_latch, &tk);
 
 	timekeeping_forward_now(tk);
 	/*
@@ -657,9 +682,9 @@ static int change_clocksource(void *data)
 			module_put(new->owner);
 		}
 	}
-	timekeeping_update(tk, TK_CLEAR_NTP | TK_MIRROR | TK_CLOCK_WAS_SET);
+	timekeeping_update(tk, TK_CLEAR_NTP | TK_CLOCK_WAS_SET);
 
-	write_seqcount_end(&timekeeper_seq);
+	timekeeper_write_end(&timekeeper_latch);
 	raw_spin_unlock_irqrestore(&timekeeper_lock, flags);
 
 	return 0;
@@ -674,13 +699,25 @@ static int change_clocksource(void *data)
  */
 int timekeeping_notify(struct clocksource *clock)
 {
-	struct timekeeper *tk = &timekeeper;
+	struct timekeeper *tk;
+	struct clocksource *current_clock;
+	unsigned long seq;
 
-	if (tk->clock == clock)
+	do {
+		tk = timekeeper_read_begin(&timekeeper_latch, &seq);
+		current_clock = tk->clock;
+	} while (timekeeper_read_retry(&timekeeper_latch, seq));
+	if (current_clock == clock)
 		return 0;
+
 	stop_machine(change_clocksource, clock, NULL);
 	tick_clock_notify();
-	return tk->clock == clock ? 0 : -1;
+
+	do {
+		tk = timekeeper_read_begin(&timekeeper_latch, &seq);
+		current_clock = tk->clock;
+	} while (timekeeper_read_retry(&timekeeper_latch, seq));
+	return current_clock == clock ? 0 : -1;
 }
 
 /**
@@ -706,16 +743,15 @@ EXPORT_SYMBOL_GPL(ktime_get_real);
  */
 void getrawmonotonic(struct timespec *ts)
 {
-	struct timekeeper *tk = &timekeeper;
+	struct timekeeper *tk;
 	unsigned long seq;
 	s64 nsecs;
 
 	do {
-		seq = read_seqcount_begin(&timekeeper_seq);
+		tk = timekeeper_read_begin(&timekeeper_latch, &seq);
 		nsecs = timekeeping_get_ns_raw(tk);
 		*ts = tk->raw_time;
-
-	} while (read_seqcount_retry(&timekeeper_seq, seq));
+	} while (timekeeper_read_retry(&timekeeper_latch, seq));
 
 	timespec_add_ns(ts, nsecs);
 }
@@ -726,16 +762,14 @@ EXPORT_SYMBOL(getrawmonotonic);
  */
 int timekeeping_valid_for_hres(void)
 {
-	struct timekeeper *tk = &timekeeper;
+	struct timekeeper *tk;
 	unsigned long seq;
 	int ret;
 
 	do {
-		seq = read_seqcount_begin(&timekeeper_seq);
-
+		tk = timekeeper_read_begin(&timekeeper_latch, &seq);
 		ret = tk->clock->flags & CLOCK_SOURCE_VALID_FOR_HRES;
-
-	} while (read_seqcount_retry(&timekeeper_seq, seq));
+	} while (timekeeper_read_retry(&timekeeper_latch, seq));
 
 	return ret;
 }
@@ -745,16 +779,14 @@ int timekeeping_valid_for_hres(void)
  */
 u64 timekeeping_max_deferment(void)
 {
-	struct timekeeper *tk = &timekeeper;
+	struct timekeeper *tk;
 	unsigned long seq;
 	u64 ret;
 
 	do {
-		seq = read_seqcount_begin(&timekeeper_seq);
-
+		tk = timekeeper_read_begin(&timekeeper_latch, &seq);
 		ret = tk->clock->max_idle_ns;
-
-	} while (read_seqcount_retry(&timekeeper_seq, seq));
+	} while (timekeeper_read_retry(&timekeeper_latch, seq));
 
 	return ret;
 }
@@ -794,7 +826,7 @@ void __attribute__((weak)) read_boot_clock(struct timespec *ts)
  */
 void __init timekeeping_init(void)
 {
-	struct timekeeper *tk = &timekeeper;
+	struct timekeeper *tk;
 	struct clocksource *clock;
 	unsigned long flags;
 	struct timespec now, boot, tmp;
@@ -818,7 +850,7 @@ void __init timekeeping_init(void)
 	}
 
 	raw_spin_lock_irqsave(&timekeeper_lock, flags);
-	write_seqcount_begin(&timekeeper_seq);
+	timekeeper_write_begin(&timekeeper_latch, &tk);
 	ntp_init(&tk->ntp);
 
 	clock = clocksource_default_clock();
@@ -839,9 +871,7 @@ void __init timekeeping_init(void)
 	tmp.tv_nsec = 0;
 	tk_set_sleep_time(tk, tmp);
 
-	memcpy(&shadow_timekeeper, &timekeeper, sizeof(timekeeper));
-
-	write_seqcount_end(&timekeeper_seq);
+	timekeeper_write_end(&timekeeper_latch);
 	raw_spin_unlock_irqrestore(&timekeeper_lock, flags);
 }
 
@@ -881,7 +911,7 @@ static void __timekeeping_inject_sleeptime(struct timekeeper *tk,
  */
 void timekeeping_inject_sleeptime(struct timespec *delta)
 {
-	struct timekeeper *tk = &timekeeper;
+	struct timekeeper *tk;
 	unsigned long flags;
 
 	/*
@@ -892,15 +922,15 @@ void timekeeping_inject_sleeptime(struct timespec *delta)
 		return;
 
 	raw_spin_lock_irqsave(&timekeeper_lock, flags);
-	write_seqcount_begin(&timekeeper_seq);
+	timekeeper_write_begin(&timekeeper_latch, &tk);
 
 	timekeeping_forward_now(tk);
 
 	__timekeeping_inject_sleeptime(tk, delta);
 
-	timekeeping_update(tk, TK_CLEAR_NTP | TK_MIRROR | TK_CLOCK_WAS_SET);
+	timekeeping_update(tk, TK_CLEAR_NTP | TK_CLOCK_WAS_SET);
 
-	write_seqcount_end(&timekeeper_seq);
+	timekeeper_write_end(&timekeeper_latch);
 	raw_spin_unlock_irqrestore(&timekeeper_lock, flags);
 
 	/* signal hrtimers about time change */
@@ -916,12 +946,13 @@ void timekeeping_inject_sleeptime(struct timespec *delta)
  */
 static void timekeeping_resume(void)
 {
-	struct timekeeper *tk = &timekeeper;
-	struct clocksource *clock = tk->clock;
+	struct timekeeper *tk;
+	struct clocksource *clock;
 	unsigned long flags;
 	struct timespec ts_new, ts_delta;
 	cycle_t cycle_now, cycle_delta;
 	bool suspendtime_found = false;
+	int tk_index;
 
 	read_persistent_clock(&ts_new);
 
@@ -929,7 +960,9 @@ static void timekeeping_resume(void)
 	clocksource_resume();
 
 	raw_spin_lock_irqsave(&timekeeper_lock, flags);
-	write_seqcount_begin(&timekeeper_seq);
+	timekeeper_write_begin(&timekeeper_latch, &tk);
+	clock = tk->clock;
+	tk_index = timekeeper_index(&timekeeper_latch, tk);
 
 	/*
 	 * After system resumes, we need to calculate the suspended time and
@@ -977,11 +1010,12 @@ static void timekeeping_resume(void)
 		__timekeeping_inject_sleeptime(tk, &ts_delta);
 
 	/* Re-base the last cycle value */
-	tk->cycle_last = clock->cycle_last = cycle_now;
+	tk->cycle_last = clock->cycle_last =
+		clock->cycle_last_latch[tk_index] = cycle_now;
 	tk->ntp_error = 0;
 	timekeeping_suspended = 0;
-	timekeeping_update(tk, TK_MIRROR | TK_CLOCK_WAS_SET);
-	write_seqcount_end(&timekeeper_seq);
+	timekeeping_update(tk, TK_CLOCK_WAS_SET);
+	timekeeper_write_end(&timekeeper_latch);
 	raw_spin_unlock_irqrestore(&timekeeper_lock, flags);
 
 	touch_softlockup_watchdog();
@@ -994,7 +1028,7 @@ static void timekeeping_resume(void)
 
 static int timekeeping_suspend(void)
 {
-	struct timekeeper *tk = &timekeeper;
+	struct timekeeper *tk;
 	unsigned long flags;
 	struct timespec		delta, delta_delta;
 	static struct timespec	old_delta;
@@ -1010,7 +1044,7 @@ static int timekeeping_suspend(void)
 		persistent_clock_exist = true;
 
 	raw_spin_lock_irqsave(&timekeeper_lock, flags);
-	write_seqcount_begin(&timekeeper_seq);
+	timekeeper_write_begin(&timekeeper_latch, &tk);
 	timekeeping_forward_now(tk);
 	timekeeping_suspended = 1;
 
@@ -1033,7 +1067,7 @@ static int timekeeping_suspend(void)
 		timekeeping_suspend_time =
 			timespec_add(timekeeping_suspend_time, delta_delta);
 	}
-	write_seqcount_end(&timekeeper_seq);
+	timekeeper_write_end(&timekeeper_latch);
 	raw_spin_unlock_irqrestore(&timekeeper_lock, flags);
 
 	clockevents_notify(CLOCK_EVT_NOTIFY_SUSPEND, NULL);
@@ -1372,29 +1406,31 @@ static inline void old_vsyscall_fixup(struct timekeeper *tk)
 static void update_wall_time(void)
 {
 	struct clocksource *clock;
-	struct timekeeper *real_tk = &timekeeper;
-	struct timekeeper *tk = &shadow_timekeeper;
+	struct timekeeper *tk;
 	cycle_t offset;
 	int shift = 0, maxshift;
 	unsigned int action;
 	unsigned long flags;
+	int tk_index;
 
 	raw_spin_lock_irqsave(&timekeeper_lock, flags);
+	timekeeper_write_begin(&timekeeper_latch, &tk);
+	tk_index = timekeeper_index(&timekeeper_latch, tk);
 
 	/* Make sure we're fully resumed: */
 	if (unlikely(timekeeping_suspended))
 		goto out;
 
-	clock = real_tk->clock;
+	clock = tk->clock;
 
 #ifdef CONFIG_ARCH_USES_GETTIMEOFFSET
-	offset = real_tk->cycle_interval;
+	offset = tk->cycle_interval;
 #else
 	offset = (clock->read(clock) - clock->cycle_last) & clock->mask;
 #endif
 
 	/* Check if there's really nothing to do */
-	if (offset < real_tk->cycle_interval)
+	if (offset < tk->cycle_interval)
 		goto out;
 
 	/*
@@ -1431,23 +1467,11 @@ static void update_wall_time(void)
 	 */
 	action = accumulate_nsecs_to_secs(tk);
 
-	write_seqcount_begin(&timekeeper_seq);
 	/* Update clock->cycle_last with the new value */
-	clock->cycle_last = tk->cycle_last;
-	/*
-	 * Update the real timekeeper.
-	 *
-	 * We could avoid this memcpy by switching pointers, but that
-	 * requires changes to all other timekeeper usage sites as
-	 * well, i.e. move the timekeeper pointer getter into the
-	 * spinlocked/seqcount protected sections. And we trade this
-	 * memcpy under the timekeeper_seq against one before we start
-	 * updating.
-	 */
-	memcpy(real_tk, tk, sizeof(*tk));
-	timekeeping_update(real_tk, action);
-	write_seqcount_end(&timekeeper_seq);
+	clock->cycle_last_latch[tk_index] = clock->cycle_last = tk->cycle_last;
+	timekeeping_update(tk, action);
 out:
+	timekeeper_write_end(&timekeeper_latch);
 	raw_spin_unlock_irqrestore(&timekeeper_lock, flags);
 }
 
@@ -1464,13 +1488,17 @@ out:
  */
 void getboottime(struct timespec *ts)
 {
-	struct timekeeper *tk = &timekeeper;
-	struct timespec boottime = {
-		.tv_sec = tk->wall_to_monotonic.tv_sec +
-				tk->total_sleep_time.tv_sec,
-		.tv_nsec = tk->wall_to_monotonic.tv_nsec +
-				tk->total_sleep_time.tv_nsec
-	};
+	struct timekeeper *tk;
+	struct timespec boottime;
+	unsigned long seq;
+
+	do {
+		tk = timekeeper_read_begin(&timekeeper_latch, &seq);
+		boottime.tv_sec = tk->wall_to_monotonic.tv_sec +
+				tk->total_sleep_time.tv_sec;
+		boottime.tv_nsec = tk->wall_to_monotonic.tv_nsec +
+				tk->total_sleep_time.tv_nsec;
+	} while (timekeeper_read_retry(&timekeeper_latch, seq));
 
 	set_normalized_timespec(ts, -boottime.tv_sec, -boottime.tv_nsec);
 }
@@ -1487,21 +1515,20 @@ EXPORT_SYMBOL_GPL(getboottime);
  */
 void get_monotonic_boottime(struct timespec *ts)
 {
-	struct timekeeper *tk = &timekeeper;
+	struct timekeeper *tk;
 	struct timespec tomono, sleep;
 	s64 nsec;
-	unsigned int seq;
+	unsigned long seq;
 
 	WARN_ON(timekeeping_suspended);
 
 	do {
-		seq = read_seqcount_begin(&timekeeper_seq);
+		tk = timekeeper_read_begin(&timekeeper_latch, &seq);
 		ts->tv_sec = tk->xtime_sec;
 		nsec = timekeeping_get_ns(tk);
 		tomono = tk->wall_to_monotonic;
 		sleep = tk->total_sleep_time;
-
-	} while (read_seqcount_retry(&timekeeper_seq, seq));
+	} while (timekeeper_read_retry(&timekeeper_latch, seq));
 
 	ts->tv_sec += tomono.tv_sec + sleep.tv_sec;
 	ts->tv_nsec = 0;
@@ -1532,38 +1559,57 @@ EXPORT_SYMBOL_GPL(ktime_get_boottime);
  */
 void monotonic_to_bootbased(struct timespec *ts)
 {
-	struct timekeeper *tk = &timekeeper;
+	struct timekeeper *tk;
+	struct timespec ret;
+	unsigned long seq;
+
+	do {
+		tk = timekeeper_read_begin(&timekeeper_latch, &seq);
+		ret = timespec_add(*ts, tk->total_sleep_time);
+	} while (timekeeper_read_retry(&timekeeper_latch, seq));
 
-	*ts = timespec_add(*ts, tk->total_sleep_time);
+	*ts = ret;
 }
 EXPORT_SYMBOL_GPL(monotonic_to_bootbased);
 
 unsigned long get_seconds(void)
 {
-	struct timekeeper *tk = &timekeeper;
+	struct timekeeper *tk;
+	unsigned long seq, ret;
+
+	do {
+		tk = timekeeper_read_begin(&timekeeper_latch, &seq);
+		ret = tk->xtime_sec;
+	} while (timekeeper_read_retry(&timekeeper_latch, seq));
 
-	return tk->xtime_sec;
+	return ret;
 }
 EXPORT_SYMBOL(get_seconds);
 
 struct timespec __current_kernel_time(void)
 {
-	struct timekeeper *tk = &timekeeper;
+	struct timekeeper *tk;
+	unsigned long seq;
+	struct timespec ret;
+
+	do {
+		tk = timekeeper_read_begin(&timekeeper_latch, &seq);
+		ret = tk_xtime(tk);
+	} while (timekeeper_read_retry(&timekeeper_latch, seq));
 
-	return tk_xtime(tk);
+	return ret;
 }
 
 struct timespec current_kernel_time(void)
 {
-	struct timekeeper *tk = &timekeeper;
+	struct timekeeper *tk;
 	struct timespec now;
 	unsigned long seq;
 
 	do {
-		seq = read_seqcount_begin(&timekeeper_seq);
-
+		tk = timekeeper_read_begin(&timekeeper_latch, &seq);
 		now = tk_xtime(tk);
-	} while (read_seqcount_retry(&timekeeper_seq, seq));
+	} while (timekeeper_read_retry(&timekeeper_latch, seq));
 
 	return now;
 }
@@ -1571,16 +1617,15 @@ EXPORT_SYMBOL(current_kernel_time);
 
 struct timespec get_monotonic_coarse(void)
 {
-	struct timekeeper *tk = &timekeeper;
+	struct timekeeper *tk;
 	struct timespec now, mono;
 	unsigned long seq;
 
 	do {
-		seq = read_seqcount_begin(&timekeeper_seq);
-
+		tk = timekeeper_read_begin(&timekeeper_latch, &seq);
 		now = tk_xtime(tk);
 		mono = tk->wall_to_monotonic;
-	} while (read_seqcount_retry(&timekeeper_seq, seq));
+	} while (timekeeper_read_retry(&timekeeper_latch, seq));
 
 	set_normalized_timespec(&now, now.tv_sec + mono.tv_sec,
 				now.tv_nsec + mono.tv_nsec);
@@ -1607,15 +1652,15 @@ void do_timer(unsigned long ticks)
 void get_xtime_and_monotonic_and_sleep_offset(struct timespec *xtim,
 				struct timespec *wtom, struct timespec *sleep)
 {
-	struct timekeeper *tk = &timekeeper;
+	struct timekeeper *tk;
 	unsigned long seq;
 
 	do {
-		seq = read_seqcount_begin(&timekeeper_seq);
+		tk = timekeeper_read_begin(&timekeeper_latch, &seq);
 		*xtim = tk_xtime(tk);
 		*wtom = tk->wall_to_monotonic;
 		*sleep = tk->total_sleep_time;
-	} while (read_seqcount_retry(&timekeeper_seq, seq));
+	} while (timekeeper_read_retry(&timekeeper_latch, seq));
 }
 
 #ifdef CONFIG_HIGH_RES_TIMERS
@@ -1630,13 +1675,13 @@ void get_xtime_and_monotonic_and_sleep_offset(struct timespec *xtim,
 ktime_t ktime_get_update_offsets(ktime_t *offs_real, ktime_t *offs_boot,
 							ktime_t *offs_tai)
 {
-	struct timekeeper *tk = &timekeeper;
+	struct timekeeper *tk;
 	ktime_t now;
-	unsigned int seq;
+	unsigned long seq;
 	u64 secs, nsecs;
 
 	do {
-		seq = read_seqcount_begin(&timekeeper_seq);
+		tk = timekeeper_read_begin(&timekeeper_latch, &seq);
 
 		secs = tk->xtime_sec;
 		nsecs = timekeeping_get_ns(tk);
@@ -1644,7 +1689,7 @@ ktime_t ktime_get_update_offsets(ktime_t *offs_real, ktime_t *offs_boot,
 		*offs_real = tk->offs_real;
 		*offs_boot = tk->offs_boot;
 		*offs_tai = tk->offs_tai;
-	} while (read_seqcount_retry(&timekeeper_seq, seq));
+	} while (timekeeper_read_retry(&timekeeper_latch, seq));
 
 	now = ktime_add_ns(ktime_set(secs, 0), nsecs);
 	now = ktime_sub(now, *offs_real);
@@ -1657,14 +1702,14 @@ ktime_t ktime_get_update_offsets(ktime_t *offs_real, ktime_t *offs_boot,
  */
 ktime_t ktime_get_monotonic_offset(void)
 {
-	struct timekeeper *tk = &timekeeper;
+	struct timekeeper *tk;
 	unsigned long seq;
 	struct timespec wtom;
 
 	do {
-		seq = read_seqcount_begin(&timekeeper_seq);
+		tk = timekeeper_read_begin(&timekeeper_latch, &seq);
 		wtom = tk->wall_to_monotonic;
-	} while (read_seqcount_retry(&timekeeper_seq, seq));
+	} while (timekeeper_read_retry(&timekeeper_latch, seq));
 
 	return timespec_to_ktime(wtom);
 }
@@ -1675,7 +1720,7 @@ EXPORT_SYMBOL_GPL(ktime_get_monotonic_offset);
  */
 int do_adjtimex(struct timex *txc)
 {
-	struct timekeeper *tk = &timekeeper;
+	struct timekeeper *tk;
 	unsigned long flags;
 	struct timespec ts;
 	s32 orig_tai, tai;
@@ -1700,7 +1745,7 @@ int do_adjtimex(struct timex *txc)
 	getnstimeofday(&ts);
 
 	raw_spin_lock_irqsave(&timekeeper_lock, flags);
-	write_seqcount_begin(&timekeeper_seq);
+	timekeeper_write_begin(&timekeeper_latch, &tk);
 
 	orig_tai = tai = tk->tai_offset;
 	ret = __do_adjtimex(&tk->ntp, txc, &ts, &tai);
@@ -1710,7 +1755,7 @@ int do_adjtimex(struct timex *txc)
 		update_pvclock_gtod(tk, true);
 		clock_was_set_delayed();
 	}
-	write_seqcount_end(&timekeeper_seq);
+	timekeeper_write_end(&timekeeper_latch);
 	raw_spin_unlock_irqrestore(&timekeeper_lock, flags);
 
 	ntp_notify_cmos_timer();
@@ -1724,15 +1769,15 @@ int do_adjtimex(struct timex *txc)
  */
 void hardpps(const struct timespec *phase_ts, const struct timespec *raw_ts)
 {
-	struct timekeeper *tk = &timekeeper;
+	struct timekeeper *tk;
 	unsigned long flags;
 
 	raw_spin_lock_irqsave(&timekeeper_lock, flags);
-	write_seqcount_begin(&timekeeper_seq);
+	timekeeper_write_begin(&timekeeper_latch, &tk);
 
 	__hardpps(&tk->ntp, phase_ts, raw_ts);
 
-	write_seqcount_end(&timekeeper_seq);
+	timekeeper_write_end(&timekeeper_latch);
 	raw_spin_unlock_irqrestore(&timekeeper_lock, flags);
 }
 EXPORT_SYMBOL(hardpps);
-- 
1.7.10.4