Merge branch 'fortglx/4.13/time' of... (17d9d687) · Commits · e / devices / android_kernel_fairphone_FP4

arch/arm64/kernel/vdso.c

+2 −4

Original line number	Diff line number	Diff line
		@@ -220,10 +220,8 @@ void update_vsyscall(struct timekeeper *tk)
		if (!use_syscall) {
		/* tkr_mono.cycle_last == tkr_raw.cycle_last */
		vdso_data->cs_cycle_last = tk->tkr_mono.cycle_last;
		vdso_data->raw_time_sec = tk->raw_time.tv_sec;
		vdso_data->raw_time_nsec = (tk->raw_time.tv_nsec <<
		tk->tkr_raw.shift) +
		tk->tkr_raw.xtime_nsec;
		vdso_data->raw_time_sec = tk->raw_sec;
		vdso_data->raw_time_nsec = tk->tkr_raw.xtime_nsec;
		vdso_data->xtime_clock_sec = tk->xtime_sec;
		vdso_data->xtime_clock_nsec = tk->tkr_mono.xtime_nsec;
		vdso_data->cs_mono_mult = tk->tkr_mono.mult;

include/linux/timekeeper_internal.h

+2 −2

Original line number	Diff line number	Diff line
		@@ -51,7 +51,7 @@ struct tk_read_base {
		* @clock_was_set_seq: The sequence number of clock was set events
		* @cs_was_changed_seq: The sequence number of clocksource change events
		* @next_leap_ktime: CLOCK_MONOTONIC time value of a pending leap-second
		* @raw_time: Monotonic raw base time in timespec64 format
		* @raw_sec: CLOCK_MONOTONIC_RAW time in seconds
		* @cycle_interval: Number of clock cycles in one NTP interval
		* @xtime_interval: Number of clock shifted nano seconds in one NTP
		* interval.
		@@ -93,7 +93,7 @@ struct timekeeper {
		unsigned int clock_was_set_seq;
		u8 cs_was_changed_seq;
		ktime_t next_leap_ktime;
		struct timespec64 raw_time;
		u64 raw_sec;

		/* The following members are for timekeeping internal use */
		u64 cycle_interval;

kernel/time/timekeeping.c

+26 −20

Original line number	Diff line number	Diff line
		@@ -72,6 +72,10 @@ static inline void tk_normalize_xtime(struct timekeeper *tk)
		tk->tkr_mono.xtime_nsec -= (u64)NSEC_PER_SEC << tk->tkr_mono.shift;
		tk->xtime_sec++;
		}
		while (tk->tkr_raw.xtime_nsec >= ((u64)NSEC_PER_SEC << tk->tkr_raw.shift)) {
		tk->tkr_raw.xtime_nsec -= (u64)NSEC_PER_SEC << tk->tkr_raw.shift;
		tk->raw_sec++;
		}
		}

		static inline struct timespec64 tk_xtime(struct timekeeper *tk)
		@@ -285,12 +289,14 @@ static void tk_setup_internals(struct timekeeper tk, struct clocksource clock)
		/* if changing clocks, convert xtime_nsec shift units */
		if (old_clock) {
		int shift_change = clock->shift - old_clock->shift;
		if (shift_change < 0)
		if (shift_change < 0) {
		tk->tkr_mono.xtime_nsec >>= -shift_change;
		else
		tk->tkr_raw.xtime_nsec >>= -shift_change;
		} else {
		tk->tkr_mono.xtime_nsec <<= shift_change;
		tk->tkr_raw.xtime_nsec <<= shift_change;
		}
		}
		tk->tkr_raw.xtime_nsec = 0;

		tk->tkr_mono.shift = clock->shift;
		tk->tkr_raw.shift = clock->shift;
		@@ -510,6 +516,7 @@ static void halt_fast_timekeeper(struct timekeeper *tk)
		}

		#ifdef CONFIG_GENERIC_TIME_VSYSCALL_OLD
		#warning Please contact your maintainers, as GENERIC_TIME_VSYSCALL_OLD compatibity will disappear soon.

		static inline void update_vsyscall(struct timekeeper *tk)
		{
		@@ -619,9 +626,6 @@ static inline void tk_update_ktime_data(struct timekeeper *tk)
		nsec = (u32) tk->wall_to_monotonic.tv_nsec;
		tk->tkr_mono.base = ns_to_ktime(seconds * NSEC_PER_SEC + nsec);

		/* Update the monotonic raw base */
		tk->tkr_raw.base = timespec64_to_ktime(tk->raw_time);

		/*
		* The sum of the nanoseconds portions of xtime and
		* wall_to_monotonic can be greater/equal one second. Take
		@@ -631,6 +635,11 @@ static inline void tk_update_ktime_data(struct timekeeper *tk)
		if (nsec >= NSEC_PER_SEC)
		seconds++;
		tk->ktime_sec = seconds;

		/* Update the monotonic raw base */
		seconds = tk->raw_sec;
		nsec = (u32)(tk->tkr_raw.xtime_nsec >> tk->tkr_raw.shift);
		tk->tkr_raw.base = ns_to_ktime(seconds * NSEC_PER_SEC + nsec);
		}

		/* must hold timekeeper_lock */
		@@ -672,7 +681,6 @@ static void timekeeping_update(struct timekeeper *tk, unsigned int action)
		static void timekeeping_forward_now(struct timekeeper *tk)
		{
		u64 cycle_now, delta;
		u64 nsec;

		cycle_now = tk_clock_read(&tk->tkr_mono);
		delta = clocksource_delta(cycle_now, tk->tkr_mono.cycle_last, tk->tkr_mono.mask);
		@@ -684,10 +692,13 @@ static void timekeeping_forward_now(struct timekeeper *tk)
		/* If arch requires, add in get_arch_timeoffset() */
		tk->tkr_mono.xtime_nsec += (u64)arch_gettimeoffset() << tk->tkr_mono.shift;

		tk_normalize_xtime(tk);

		nsec = clocksource_cyc2ns(delta, tk->tkr_raw.mult, tk->tkr_raw.shift);
		timespec64_add_ns(&tk->raw_time, nsec);
		tk->tkr_raw.xtime_nsec += delta * tk->tkr_raw.mult;

		/* If arch requires, add in get_arch_timeoffset() */
		tk->tkr_raw.xtime_nsec += (u64)arch_gettimeoffset() << tk->tkr_raw.shift;

		tk_normalize_xtime(tk);
		}

		/**
		@@ -1373,19 +1384,18 @@ int timekeeping_notify(struct clocksource *clock)
		void getrawmonotonic64(struct timespec64 *ts)
		{
		struct timekeeper *tk = &tk_core.timekeeper;
		struct timespec64 ts64;
		unsigned long seq;
		u64 nsecs;

		do {
		seq = read_seqcount_begin(&tk_core.seq);
		ts->tv_sec = tk->raw_sec;
		nsecs = timekeeping_get_ns(&tk->tkr_raw);
		ts64 = tk->raw_time;

		} while (read_seqcount_retry(&tk_core.seq, seq));

		timespec64_add_ns(&ts64, nsecs);
		*ts = ts64;
		ts->tv_nsec = 0;
		timespec64_add_ns(ts, nsecs);
		}
		EXPORT_SYMBOL(getrawmonotonic64);

		@@ -1509,8 +1519,7 @@ void __init timekeeping_init(void)
		tk_setup_internals(tk, clock);

		tk_set_xtime(tk, &now);
		tk->raw_time.tv_sec = 0;
		tk->raw_time.tv_nsec = 0;
		tk->raw_sec = 0;
		if (boot.tv_sec == 0 && boot.tv_nsec == 0)
		boot = tk_xtime(tk);

		@@ -2011,15 +2020,12 @@ static u64 logarithmic_accumulation(struct timekeeper *tk, u64 offset,
		*clock_set \|= accumulate_nsecs_to_secs(tk);

		/* Accumulate raw time */
		tk->tkr_raw.xtime_nsec += (u64)tk->raw_time.tv_nsec << tk->tkr_raw.shift;
		tk->tkr_raw.xtime_nsec += tk->raw_interval << shift;
		snsec_per_sec = (u64)NSEC_PER_SEC << tk->tkr_raw.shift;
		while (tk->tkr_raw.xtime_nsec >= snsec_per_sec) {
		tk->tkr_raw.xtime_nsec -= snsec_per_sec;
		tk->raw_time.tv_sec++;
		tk->raw_sec++;
		}
		tk->raw_time.tv_nsec = tk->tkr_raw.xtime_nsec >> tk->tkr_raw.shift;
		tk->tkr_raw.xtime_nsec -= (u64)tk->raw_time.tv_nsec << tk->tkr_raw.shift;

		/* Accumulate error between NTP and clock interval */
		tk->ntp_error += tk->ntp_tick << shift;

tools/testing/selftests/timers/Makefile

+3 −2

Original line number	Diff line number	Diff line
		BUILD_FLAGS = -DKTEST
		CFLAGS += -O3 -Wl,-no-as-needed -Wall $(BUILD_FLAGS)
		LDFLAGS += -lrt -lpthread
		LDFLAGS += -lrt -lpthread -lm

		# these are all "safe" tests that don't modify
		# system time or require escalated privileges
		@@ -8,7 +8,7 @@ TEST_GEN_PROGS = posix_timers nanosleep nsleep-lat set-timer-lat mqueue-lat \
		inconsistency-check raw_skew threadtest rtctest

		TEST_GEN_PROGS_EXTENDED = alarmtimer-suspend valid-adjtimex adjtick change_skew \
		skew_consistency clocksource-switch leap-a-day \
		skew_consistency clocksource-switch freq-step leap-a-day \
		leapcrash set-tai set-2038 set-tz


		@@ -24,6 +24,7 @@ run_destructive_tests: run_tests
		./change_skew
		./skew_consistency
		./clocksource-switch
		./freq-step
		./leap-a-day -s -i 10
		./leapcrash
		./set-tz

tools/testing/selftests/timers/freq-step.c

0 → 100644

+268 −0

Original line number	Diff line number	Diff line
		/*
		* This test checks the response of the system clock to frequency
		* steps made with adjtimex(). The frequency error and stability of
		* the CLOCK_MONOTONIC clock relative to the CLOCK_MONOTONIC_RAW clock
		* is measured in two intervals following the step. The test fails if
		* values from the second interval exceed specified limits.
		*
		* Copyright (C) Miroslav Lichvar <mlichvar@redhat.com> 2017
		*
		* This program is free software; you can redistribute it and/or modify
		* it under the terms of version 2 of the GNU General Public License as
		* published by the Free Software Foundation.
		*
		* This program is distributed in the hope that it will be useful, but
		* WITHOUT ANY WARRANTY; without even the implied warranty of
		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		* General Public License for more details.
		*/

		#include <math.h>
		#include <stdio.h>
		#include <sys/timex.h>
		#include <time.h>
		#include <unistd.h>

		#include "../kselftest.h"

		#define SAMPLES 100
		#define SAMPLE_READINGS 10
		#define MEAN_SAMPLE_INTERVAL 0.1
		#define STEP_INTERVAL 1.0
		#define MAX_PRECISION 100e-9
		#define MAX_FREQ_ERROR 10e-6
		#define MAX_STDDEV 1000e-9

		struct sample {
		double offset;
		double time;
		};

		static time_t mono_raw_base;
		static time_t mono_base;
		static long user_hz;
		static double precision;
		static double mono_freq_offset;

		static double diff_timespec(struct timespec ts1, struct timespec ts2)
		{
		return ts1->tv_sec - ts2->tv_sec + (ts1->tv_nsec - ts2->tv_nsec) / 1e9;
		}

		static double get_sample(struct sample *sample)
		{
		double delay, mindelay = 0.0;
		struct timespec ts1, ts2, ts3;
		int i;

		for (i = 0; i < SAMPLE_READINGS; i++) {
		clock_gettime(CLOCK_MONOTONIC_RAW, &ts1);
		clock_gettime(CLOCK_MONOTONIC, &ts2);
		clock_gettime(CLOCK_MONOTONIC_RAW, &ts3);

		ts1.tv_sec -= mono_raw_base;
		ts2.tv_sec -= mono_base;
		ts3.tv_sec -= mono_raw_base;

		delay = diff_timespec(&ts3, &ts1);
		if (delay <= 1e-9) {
		i--;
		continue;
		}

		if (!i \|\| delay < mindelay) {
		sample->offset = diff_timespec(&ts2, &ts1);
		sample->offset -= delay / 2.0;
		sample->time = ts1.tv_sec + ts1.tv_nsec / 1e9;
		mindelay = delay;
		}
		}

		return mindelay;
		}

		static void reset_ntp_error(void)
		{
		struct timex txc;

		txc.modes = ADJ_SETOFFSET;
		txc.time.tv_sec = 0;
		txc.time.tv_usec = 0;

		if (adjtimex(&txc) < 0) {
		perror("[FAIL] adjtimex");
		ksft_exit_fail();
		}
		}

		static void set_frequency(double freq)
		{
		struct timex txc;
		int tick_offset;

		tick_offset = 1e6 * freq / user_hz;

		txc.modes = ADJ_TICK \| ADJ_FREQUENCY;
		txc.tick = 1000000 / user_hz + tick_offset;
		txc.freq = (1e6 * freq - user_hz * tick_offset) * (1 << 16);

		if (adjtimex(&txc) < 0) {
		perror("[FAIL] adjtimex");
		ksft_exit_fail();
		}
		}

		static void regress(struct sample samples, int n, double intercept,
		double slope, double r_stddev, double *r_max)
		{
		double x, y, r, x_sum, y_sum, xy_sum, x2_sum, r2_sum;
		int i;

		x_sum = 0.0, y_sum = 0.0, xy_sum = 0.0, x2_sum = 0.0;

		for (i = 0; i < n; i++) {
		x = samples[i].time;
		y = samples[i].offset;

		x_sum += x;
		y_sum += y;
		xy_sum += x * y;
		x2_sum += x * x;
		}

		slope = (xy_sum - x_sum y_sum / n) / (x2_sum - x_sum * x_sum / n);
		intercept = (y_sum - slope * x_sum) / n;

		*r_max = 0.0, r2_sum = 0.0;

		for (i = 0; i < n; i++) {
		x = samples[i].time;
		y = samples[i].offset;
		r = fabs(x * slope + intercept - y);
		if (*r_max < r)
		*r_max = r;
		r2_sum += r * r;
		}

		*r_stddev = sqrt(r2_sum / n);
		}

		static int run_test(int calibration, double freq_base, double freq_step)
		{
		struct sample samples[SAMPLES];
		double intercept, slope, stddev1, max1, stddev2, max2;
		double freq_error1, freq_error2;
		int i;

		set_frequency(freq_base);

		for (i = 0; i < 10; i++)
		usleep(1e6 * MEAN_SAMPLE_INTERVAL / 10);

		reset_ntp_error();

		set_frequency(freq_base + freq_step);

		for (i = 0; i < 10; i++)
		usleep(rand() % 2000000 * STEP_INTERVAL / 10);

		set_frequency(freq_base);

		for (i = 0; i < SAMPLES; i++) {
		usleep(rand() % 2000000 * MEAN_SAMPLE_INTERVAL);
		get_sample(&samples[i]);
		}

		if (calibration) {
		regress(samples, SAMPLES, &intercept, &slope, &stddev1, &max1);
		mono_freq_offset = slope;
		printf("CLOCK_MONOTONIC_RAW frequency offset: %11.3f ppm\n",
		1e6 * mono_freq_offset);
		return 0;
		}

		regress(samples, SAMPLES / 2, &intercept, &slope, &stddev1, &max1);
		freq_error1 = slope * (1.0 - mono_freq_offset) - mono_freq_offset -
		freq_base;

		regress(samples + SAMPLES / 2, SAMPLES / 2, &intercept, &slope,
		&stddev2, &max2);
		freq_error2 = slope * (1.0 - mono_freq_offset) - mono_freq_offset -
		freq_base;

		printf("%6.0f %+10.3f %6.0f %7.0f %+10.3f %6.0f %7.0f\t",
		1e6 * freq_step,
		1e6 * freq_error1, 1e9 * stddev1, 1e9 * max1,
		1e6 * freq_error2, 1e9 * stddev2, 1e9 * max2);

		if (fabs(freq_error2) > MAX_FREQ_ERROR \|\| stddev2 > MAX_STDDEV) {
		printf("[FAIL]\n");
		return 1;
		}

		printf("[OK]\n");
		return 0;
		}

		static void init_test(void)
		{
		struct timespec ts;
		struct sample sample;

		if (clock_gettime(CLOCK_MONOTONIC_RAW, &ts)) {
		perror("[FAIL] clock_gettime(CLOCK_MONOTONIC_RAW)");
		ksft_exit_fail();
		}

		mono_raw_base = ts.tv_sec;

		if (clock_gettime(CLOCK_MONOTONIC, &ts)) {
		perror("[FAIL] clock_gettime(CLOCK_MONOTONIC)");
		ksft_exit_fail();
		}

		mono_base = ts.tv_sec;

		user_hz = sysconf(_SC_CLK_TCK);

		precision = get_sample(&sample) / 2.0;
		printf("CLOCK_MONOTONIC_RAW+CLOCK_MONOTONIC precision: %.0f ns\t\t",
		1e9 * precision);

		if (precision > MAX_PRECISION) {
		printf("[SKIP]\n");
		ksft_exit_skip();
		}

		printf("[OK]\n");
		srand(ts.tv_sec ^ ts.tv_nsec);

		run_test(1, 0.0, 0.0);
		}

		int main(int argc, char **argv)
		{
		double freq_base, freq_step;
		int i, j, fails = 0;

		init_test();

		printf("Checking response to frequency step:\n");
		printf(" Step 1st interval 2nd interval\n");
		printf(" Freq Dev Max Freq Dev Max\n");

		for (i = 2; i >= 0; i--) {
		for (j = 0; j < 5; j++) {
		freq_base = (rand() % (1 << 24) - (1 << 23)) / 65536e6;
		freq_step = 10e-6 * (1 << (6 * i));
		fails += run_test(0, freq_base, freq_step);
		}
		}

		set_frequency(0.0);

		if (fails)
		ksft_exit_fail();

		ksft_exit_pass();
		}