Commit 17d9d687 authored by Thomas Gleixner's avatar Thomas Gleixner

Merge branch 'fortglx/4.13/time' of...

Merge branch 'fortglx/4.13/time' of https://git.linaro.org/people/john.stultz/linux into timers/core

Merge time(keeping) updates from John Stultz:

  "Just a small set of changes, the biggest changes being the MONOTONIC_RAW
   handling cleanup, and a new kselftest from Miroslav. Also a a clear
   warning deprecating CONFIG_GENERIC_TIME_VSYSCALL_OLD, which affects ppc
   and ia64."
parents f0cd9ae5 76739256
...@@ -220,10 +220,8 @@ void update_vsyscall(struct timekeeper *tk) ...@@ -220,10 +220,8 @@ void update_vsyscall(struct timekeeper *tk)
if (!use_syscall) { if (!use_syscall) {
/* tkr_mono.cycle_last == tkr_raw.cycle_last */ /* tkr_mono.cycle_last == tkr_raw.cycle_last */
vdso_data->cs_cycle_last = tk->tkr_mono.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_sec = tk->raw_sec;
vdso_data->raw_time_nsec = (tk->raw_time.tv_nsec << vdso_data->raw_time_nsec = tk->tkr_raw.xtime_nsec;
tk->tkr_raw.shift) +
tk->tkr_raw.xtime_nsec;
vdso_data->xtime_clock_sec = tk->xtime_sec; vdso_data->xtime_clock_sec = tk->xtime_sec;
vdso_data->xtime_clock_nsec = tk->tkr_mono.xtime_nsec; vdso_data->xtime_clock_nsec = tk->tkr_mono.xtime_nsec;
vdso_data->cs_mono_mult = tk->tkr_mono.mult; vdso_data->cs_mono_mult = tk->tkr_mono.mult;
......
...@@ -51,7 +51,7 @@ struct tk_read_base { ...@@ -51,7 +51,7 @@ struct tk_read_base {
* @clock_was_set_seq: The sequence number of clock was set events * @clock_was_set_seq: The sequence number of clock was set events
* @cs_was_changed_seq: The sequence number of clocksource change events * @cs_was_changed_seq: The sequence number of clocksource change events
* @next_leap_ktime: CLOCK_MONOTONIC time value of a pending leap-second * @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 * @cycle_interval: Number of clock cycles in one NTP interval
* @xtime_interval: Number of clock shifted nano seconds in one NTP * @xtime_interval: Number of clock shifted nano seconds in one NTP
* interval. * interval.
...@@ -93,7 +93,7 @@ struct timekeeper { ...@@ -93,7 +93,7 @@ struct timekeeper {
unsigned int clock_was_set_seq; unsigned int clock_was_set_seq;
u8 cs_was_changed_seq; u8 cs_was_changed_seq;
ktime_t next_leap_ktime; ktime_t next_leap_ktime;
struct timespec64 raw_time; u64 raw_sec;
/* The following members are for timekeeping internal use */ /* The following members are for timekeeping internal use */
u64 cycle_interval; u64 cycle_interval;
......
...@@ -72,6 +72,10 @@ static inline void tk_normalize_xtime(struct timekeeper *tk) ...@@ -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->tkr_mono.xtime_nsec -= (u64)NSEC_PER_SEC << tk->tkr_mono.shift;
tk->xtime_sec++; 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) static inline struct timespec64 tk_xtime(struct timekeeper *tk)
...@@ -285,12 +289,14 @@ static void tk_setup_internals(struct timekeeper *tk, struct clocksource *clock) ...@@ -285,12 +289,14 @@ static void tk_setup_internals(struct timekeeper *tk, struct clocksource *clock)
/* if changing clocks, convert xtime_nsec shift units */ /* if changing clocks, convert xtime_nsec shift units */
if (old_clock) { if (old_clock) {
int shift_change = clock->shift - old_clock->shift; int shift_change = clock->shift - old_clock->shift;
if (shift_change < 0) if (shift_change < 0) {
tk->tkr_mono.xtime_nsec >>= -shift_change; 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_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_mono.shift = clock->shift;
tk->tkr_raw.shift = clock->shift; tk->tkr_raw.shift = clock->shift;
...@@ -510,6 +516,7 @@ static void halt_fast_timekeeper(struct timekeeper *tk) ...@@ -510,6 +516,7 @@ static void halt_fast_timekeeper(struct timekeeper *tk)
} }
#ifdef CONFIG_GENERIC_TIME_VSYSCALL_OLD #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) static inline void update_vsyscall(struct timekeeper *tk)
{ {
...@@ -619,9 +626,6 @@ static inline void tk_update_ktime_data(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; nsec = (u32) tk->wall_to_monotonic.tv_nsec;
tk->tkr_mono.base = ns_to_ktime(seconds * NSEC_PER_SEC + 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 * The sum of the nanoseconds portions of xtime and
* wall_to_monotonic can be greater/equal one second. Take * wall_to_monotonic can be greater/equal one second. Take
...@@ -631,6 +635,11 @@ static inline void tk_update_ktime_data(struct timekeeper *tk) ...@@ -631,6 +635,11 @@ static inline void tk_update_ktime_data(struct timekeeper *tk)
if (nsec >= NSEC_PER_SEC) if (nsec >= NSEC_PER_SEC)
seconds++; seconds++;
tk->ktime_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 */ /* must hold timekeeper_lock */
...@@ -672,7 +681,6 @@ static void timekeeping_update(struct timekeeper *tk, unsigned int action) ...@@ -672,7 +681,6 @@ static void timekeeping_update(struct timekeeper *tk, unsigned int action)
static void timekeeping_forward_now(struct timekeeper *tk) static void timekeeping_forward_now(struct timekeeper *tk)
{ {
u64 cycle_now, delta; u64 cycle_now, delta;
u64 nsec;
cycle_now = tk_clock_read(&tk->tkr_mono); cycle_now = tk_clock_read(&tk->tkr_mono);
delta = clocksource_delta(cycle_now, tk->tkr_mono.cycle_last, tk->tkr_mono.mask); 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) ...@@ -684,10 +692,13 @@ static void timekeeping_forward_now(struct timekeeper *tk)
/* If arch requires, add in get_arch_timeoffset() */ /* If arch requires, add in get_arch_timeoffset() */
tk->tkr_mono.xtime_nsec += (u64)arch_gettimeoffset() << tk->tkr_mono.shift; 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); tk->tkr_raw.xtime_nsec += delta * tk->tkr_raw.mult;
timespec64_add_ns(&tk->raw_time, nsec);
/* 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) ...@@ -1373,19 +1384,18 @@ int timekeeping_notify(struct clocksource *clock)
void getrawmonotonic64(struct timespec64 *ts) void getrawmonotonic64(struct timespec64 *ts)
{ {
struct timekeeper *tk = &tk_core.timekeeper; struct timekeeper *tk = &tk_core.timekeeper;
struct timespec64 ts64;
unsigned long seq; unsigned long seq;
u64 nsecs; u64 nsecs;
do { do {
seq = read_seqcount_begin(&tk_core.seq); seq = read_seqcount_begin(&tk_core.seq);
ts->tv_sec = tk->raw_sec;
nsecs = timekeeping_get_ns(&tk->tkr_raw); nsecs = timekeeping_get_ns(&tk->tkr_raw);
ts64 = tk->raw_time;
} while (read_seqcount_retry(&tk_core.seq, seq)); } while (read_seqcount_retry(&tk_core.seq, seq));
timespec64_add_ns(&ts64, nsecs); ts->tv_nsec = 0;
*ts = ts64; timespec64_add_ns(ts, nsecs);
} }
EXPORT_SYMBOL(getrawmonotonic64); EXPORT_SYMBOL(getrawmonotonic64);
...@@ -1509,8 +1519,7 @@ void __init timekeeping_init(void) ...@@ -1509,8 +1519,7 @@ void __init timekeeping_init(void)
tk_setup_internals(tk, clock); tk_setup_internals(tk, clock);
tk_set_xtime(tk, &now); tk_set_xtime(tk, &now);
tk->raw_time.tv_sec = 0; tk->raw_sec = 0;
tk->raw_time.tv_nsec = 0;
if (boot.tv_sec == 0 && boot.tv_nsec == 0) if (boot.tv_sec == 0 && boot.tv_nsec == 0)
boot = tk_xtime(tk); boot = tk_xtime(tk);
...@@ -2011,15 +2020,12 @@ static u64 logarithmic_accumulation(struct timekeeper *tk, u64 offset, ...@@ -2011,15 +2020,12 @@ static u64 logarithmic_accumulation(struct timekeeper *tk, u64 offset,
*clock_set |= accumulate_nsecs_to_secs(tk); *clock_set |= accumulate_nsecs_to_secs(tk);
/* Accumulate raw time */ /* 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; tk->tkr_raw.xtime_nsec += tk->raw_interval << shift;
snsec_per_sec = (u64)NSEC_PER_SEC << tk->tkr_raw.shift; snsec_per_sec = (u64)NSEC_PER_SEC << tk->tkr_raw.shift;
while (tk->tkr_raw.xtime_nsec >= snsec_per_sec) { while (tk->tkr_raw.xtime_nsec >= snsec_per_sec) {
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 */ /* Accumulate error between NTP and clock interval */
tk->ntp_error += tk->ntp_tick << shift; tk->ntp_error += tk->ntp_tick << shift;
......
BUILD_FLAGS = -DKTEST BUILD_FLAGS = -DKTEST
CFLAGS += -O3 -Wl,-no-as-needed -Wall $(BUILD_FLAGS) 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 # these are all "safe" tests that don't modify
# system time or require escalated privileges # system time or require escalated privileges
...@@ -8,7 +8,7 @@ TEST_GEN_PROGS = posix_timers nanosleep nsleep-lat set-timer-lat mqueue-lat \ ...@@ -8,7 +8,7 @@ TEST_GEN_PROGS = posix_timers nanosleep nsleep-lat set-timer-lat mqueue-lat \
inconsistency-check raw_skew threadtest rtctest inconsistency-check raw_skew threadtest rtctest
TEST_GEN_PROGS_EXTENDED = alarmtimer-suspend valid-adjtimex adjtick change_skew \ 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 leapcrash set-tai set-2038 set-tz
...@@ -24,6 +24,7 @@ run_destructive_tests: run_tests ...@@ -24,6 +24,7 @@ run_destructive_tests: run_tests
./change_skew ./change_skew
./skew_consistency ./skew_consistency
./clocksource-switch ./clocksource-switch
./freq-step
./leap-a-day -s -i 10 ./leap-a-day -s -i 10
./leapcrash ./leapcrash
./set-tz ./set-tz
......
/*
* 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();
}
...@@ -118,7 +118,7 @@ int consistency_test(int clock_type, unsigned long seconds) ...@@ -118,7 +118,7 @@ int consistency_test(int clock_type, unsigned long seconds)
start_str = ctime(&t); start_str = ctime(&t);
while (seconds == -1 || now - then < seconds) { while (seconds == -1 || now - then < seconds) {
inconsistent = 0; inconsistent = -1;
/* Fill list */ /* Fill list */
for (i = 0; i < CALLS_PER_LOOP; i++) for (i = 0; i < CALLS_PER_LOOP; i++)
...@@ -130,7 +130,7 @@ int consistency_test(int clock_type, unsigned long seconds) ...@@ -130,7 +130,7 @@ int consistency_test(int clock_type, unsigned long seconds)
inconsistent = i; inconsistent = i;
/* display inconsistency */ /* display inconsistency */
if (inconsistent) { if (inconsistent >= 0) {
unsigned long long delta; unsigned long long delta;
printf("\%s\n", start_str); printf("\%s\n", start_str);
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment