Merge branch 'fortglx/4.5/time' of https://git.linaro.org/people/john.stultz/linux into timers/core (e2666d69) · Commits · EulixOS / Software / Kernel

MAINTAINERS

+2 −1

Original line number	Diff line number	Diff line
		@@ -9348,7 +9348,7 @@ M: Andreas Noever <andreas.noever@gmail.com>
		S: Maintained
		F: drivers/thunderbolt/

		TIMEKEEPING, CLOCKSOURCE CORE, NTP
		TIMEKEEPING, CLOCKSOURCE CORE, NTP, ALARMTIMER
		M: John Stultz <john.stultz@linaro.org>
		M: Thomas Gleixner <tglx@linutronix.de>
		L: linux-kernel@vger.kernel.org
		@@ -9361,6 +9361,7 @@ F: include/uapi/linux/time.h
		F: include/uapi/linux/timex.h
		F: kernel/time/clocksource.c
		F: kernel/time/time*.c
		F: kernel/time/alarmtimer.c
		F: kernel/time/ntp.c
		F: tools/testing/selftests/timers/

include/linux/time.h

+26 −0

Original line number	Diff line number	Diff line
		@@ -125,6 +125,32 @@ static inline bool timeval_valid(const struct timeval *tv)

		extern struct timespec timespec_trunc(struct timespec t, unsigned gran);

		/*
		* Validates if a timespec/timeval used to inject a time offset is valid.
		* Offsets can be postive or negative. The value of the timeval/timespec
		* is the sum of its fields, but NOTE: the field tv_usec/tv_nsec must
		* always be non-negative.
		*/
		static inline bool timeval_inject_offset_valid(const struct timeval *tv)
		{
		/* We don't check the tv_sec as it can be positive or negative */

		/* Can't have more microseconds then a second */
		if (tv->tv_usec < 0 \|\| tv->tv_usec >= USEC_PER_SEC)
		return false;
		return true;
		}

		static inline bool timespec_inject_offset_valid(const struct timespec *ts)
		{
		/* We don't check the tv_sec as it can be positive or negative */

		/* Can't have more nanoseconds then a second */
		if (ts->tv_nsec < 0 \|\| ts->tv_nsec >= NSEC_PER_SEC)
		return false;
		return true;
		}

		#define CURRENT_TIME (current_kernel_time())
		#define CURRENT_TIME_SEC ((struct timespec) { get_seconds(), 0 })

kernel/time/alarmtimer.c

+17 −0

Original line number	Diff line number	Diff line
		@@ -271,11 +271,27 @@ static int alarmtimer_suspend(struct device *dev)
		__pm_wakeup_event(ws, MSEC_PER_SEC);
		return ret;
		}

		static int alarmtimer_resume(struct device *dev)
		{
		struct rtc_device *rtc;

		rtc = alarmtimer_get_rtcdev();
		if (rtc)
		rtc_timer_cancel(rtc, &rtctimer);
		return 0;
		}

		#else
		static int alarmtimer_suspend(struct device *dev)
		{
		return 0;
		}

		static int alarmtimer_resume(struct device *dev)
		{
		return 0;
		}
		#endif

		static void alarmtimer_freezerset(ktime_t absexp, enum alarmtimer_type type)
		@@ -800,6 +816,7 @@ static int alarm_timer_nsleep(const clockid_t which_clock, int flags,
		/* Suspend hook structures */
		static const struct dev_pm_ops alarmtimer_pm_ops = {
		.suspend = alarmtimer_suspend,
		.resume = alarmtimer_resume,
		};

		static struct platform_driver alarmtimer_driver = {

kernel/time/clocksource.c

+2 −2

Original line number	Diff line number	Diff line
		@@ -218,8 +218,8 @@ static void clocksource_watchdog(unsigned long data)

		/* Check the deviation from the watchdog clocksource. */
		if (abs(cs_nsec - wd_nsec) > WATCHDOG_THRESHOLD) {
		pr_warn("timekeeping watchdog: Marking clocksource '%s' as unstable because the skew is too large:\n",
		cs->name);
		pr_warn("timekeeping watchdog on CPU%d: Marking clocksource '%s' as unstable because the skew is too large:\n",
		smp_processor_id(), cs->name);
		pr_warn(" '%s' wd_now: %llx wd_last: %llx mask: %llx\n",
		watchdog->name, wdnow, wdlast, watchdog->mask);
		pr_warn(" '%s' cs_now: %llx cs_last: %llx mask: %llx\n",

kernel/time/ntp.c

+28 −16

Original line number	Diff line number	Diff line
		@@ -16,8 +16,11 @@
		#include <linux/mm.h>
		#include <linux/module.h>
		#include <linux/rtc.h>
		#include <linux/math64.h>

		#include "ntp_internal.h"
		#include "timekeeping_internal.h"


		/*
		* NTP timekeeping variables:
		@@ -70,7 +73,7 @@ static long time_esterror = NTP_PHASE_LIMIT;
		static s64 time_freq;

		/* time at last adjustment (secs): */
		static long time_reftime;
		static time64_t time_reftime;

		static long time_adjust;

		@@ -297,25 +300,27 @@ static void ntp_update_offset(long offset)
		if (!(time_status & STA_PLL))
		return;

		if (!(time_status & STA_NANO))
		if (!(time_status & STA_NANO)) {
		/* Make sure the multiplication below won't overflow */
		offset = clamp(offset, -USEC_PER_SEC, USEC_PER_SEC);
		offset *= NSEC_PER_USEC;
		}

		/*
		* Scale the phase adjustment and
		* clamp to the operating range.
		*/
		offset = min(offset, MAXPHASE);
		offset = max(offset, -MAXPHASE);
		offset = clamp(offset, -MAXPHASE, MAXPHASE);

		/*
		* Select how the frequency is to be controlled
		* and in which mode (PLL or FLL).
		*/
		secs = get_seconds() - time_reftime;
		secs = (long)(__ktime_get_real_seconds() - time_reftime);
		if (unlikely(time_status & STA_FREQHOLD))
		secs = 0;

		time_reftime = get_seconds();
		time_reftime = __ktime_get_real_seconds();

		offset64 = offset;
		freq_adj = ntp_update_offset_fll(offset64, secs);
		@@ -390,10 +395,11 @@ ktime_t ntp_get_next_leap(void)
		*
		* Also handles leap second processing, and returns leap offset
		*/
		int second_overflow(unsigned long secs)
		int second_overflow(time64_t secs)
		{
		s64 delta;
		int leap = 0;
		s32 rem;

		/*
		* Leap second processing. If in leap-insert state at the end of the
		@@ -404,19 +410,19 @@ int second_overflow(unsigned long secs)
		case TIME_OK:
		if (time_status & STA_INS) {
		time_state = TIME_INS;
		ntp_next_leap_sec = secs + SECS_PER_DAY -
		(secs % SECS_PER_DAY);
		div_s64_rem(secs, SECS_PER_DAY, &rem);
		ntp_next_leap_sec = secs + SECS_PER_DAY - rem;
		} else if (time_status & STA_DEL) {
		time_state = TIME_DEL;
		ntp_next_leap_sec = secs + SECS_PER_DAY -
		((secs+1) % SECS_PER_DAY);
		div_s64_rem(secs + 1, SECS_PER_DAY, &rem);
		ntp_next_leap_sec = secs + SECS_PER_DAY - rem;
		}
		break;
		case TIME_INS:
		if (!(time_status & STA_INS)) {
		ntp_next_leap_sec = TIME64_MAX;
		time_state = TIME_OK;
		} else if (secs % SECS_PER_DAY == 0) {
		} else if (secs == ntp_next_leap_sec) {
		leap = -1;
		time_state = TIME_OOP;
		printk(KERN_NOTICE
		@@ -427,7 +433,7 @@ int second_overflow(unsigned long secs)
		if (!(time_status & STA_DEL)) {
		ntp_next_leap_sec = TIME64_MAX;
		time_state = TIME_OK;
		} else if ((secs + 1) % SECS_PER_DAY == 0) {
		} else if (secs == ntp_next_leap_sec) {
		leap = 1;
		ntp_next_leap_sec = TIME64_MAX;
		time_state = TIME_WAIT;
		@@ -590,7 +596,7 @@ static inline void process_adj_status(struct timex txc, struct timespec64 ts)
		* reference time to current time.
		*/
		if (!(time_status & STA_PLL) && (txc->status & STA_PLL))
		time_reftime = get_seconds();
		time_reftime = __ktime_get_real_seconds();

		/* only set allowed bits */
		time_status &= STA_RONLY;
		@@ -674,9 +680,15 @@ int ntp_validate_timex(struct timex *txc)
		return -EINVAL;
		}

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

		if (!timeval_inject_offset_valid(&txc->time))
		return -EINVAL;
		}

		/*
		* Check for potential multiplication overflows that can
		* only happen on 64-bit systems: