95b0867996
vdso vgetns() didn't mask the time source offset calculation, which could lead to time problems with 32bit HPET. Add the masking. Thanks to Chuck Ebbert for tracking this down. Signed-off-by: Andi Kleen <ak@suse.de> Cc: Chuck Ebbert <cebbert@redhat.com> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
122 lines
3.1 KiB
C
122 lines
3.1 KiB
C
/*
|
|
* Copyright 2006 Andi Kleen, SUSE Labs.
|
|
* Subject to the GNU Public License, v.2
|
|
*
|
|
* Fast user context implementation of clock_gettime and gettimeofday.
|
|
*
|
|
* The code should have no internal unresolved relocations.
|
|
* Check with readelf after changing.
|
|
* Also alternative() doesn't work.
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/posix-timers.h>
|
|
#include <linux/time.h>
|
|
#include <linux/string.h>
|
|
#include <asm/vsyscall.h>
|
|
#include <asm/vgtod.h>
|
|
#include <asm/timex.h>
|
|
#include <asm/hpet.h>
|
|
#include <asm/unistd.h>
|
|
#include <asm/io.h>
|
|
#include <asm/vgtod.h>
|
|
#include "vextern.h"
|
|
|
|
#define gtod vdso_vsyscall_gtod_data
|
|
|
|
static long vdso_fallback_gettime(long clock, struct timespec *ts)
|
|
{
|
|
long ret;
|
|
asm("syscall" : "=a" (ret) :
|
|
"0" (__NR_clock_gettime),"D" (clock), "S" (ts) : "memory");
|
|
return ret;
|
|
}
|
|
|
|
static inline long vgetns(void)
|
|
{
|
|
long v;
|
|
cycles_t (*vread)(void);
|
|
vread = gtod->clock.vread;
|
|
v = (vread() - gtod->clock.cycle_last) & gtod->clock.mask;
|
|
return (v * gtod->clock.mult) >> gtod->clock.shift;
|
|
}
|
|
|
|
static noinline int do_realtime(struct timespec *ts)
|
|
{
|
|
unsigned long seq, ns;
|
|
do {
|
|
seq = read_seqbegin(>od->lock);
|
|
ts->tv_sec = gtod->wall_time_sec;
|
|
ts->tv_nsec = gtod->wall_time_nsec;
|
|
ns = vgetns();
|
|
} while (unlikely(read_seqretry(>od->lock, seq)));
|
|
timespec_add_ns(ts, ns);
|
|
return 0;
|
|
}
|
|
|
|
/* Copy of the version in kernel/time.c which we cannot directly access */
|
|
static void vset_normalized_timespec(struct timespec *ts, long sec, long nsec)
|
|
{
|
|
while (nsec >= NSEC_PER_SEC) {
|
|
nsec -= NSEC_PER_SEC;
|
|
++sec;
|
|
}
|
|
while (nsec < 0) {
|
|
nsec += NSEC_PER_SEC;
|
|
--sec;
|
|
}
|
|
ts->tv_sec = sec;
|
|
ts->tv_nsec = nsec;
|
|
}
|
|
|
|
static noinline int do_monotonic(struct timespec *ts)
|
|
{
|
|
unsigned long seq, ns, secs;
|
|
do {
|
|
seq = read_seqbegin(>od->lock);
|
|
secs = gtod->wall_time_sec;
|
|
ns = gtod->wall_time_nsec + vgetns();
|
|
secs += gtod->wall_to_monotonic.tv_sec;
|
|
ns += gtod->wall_to_monotonic.tv_nsec;
|
|
} while (unlikely(read_seqretry(>od->lock, seq)));
|
|
vset_normalized_timespec(ts, secs, ns);
|
|
return 0;
|
|
}
|
|
|
|
int __vdso_clock_gettime(clockid_t clock, struct timespec *ts)
|
|
{
|
|
if (likely(gtod->sysctl_enabled && gtod->clock.vread))
|
|
switch (clock) {
|
|
case CLOCK_REALTIME:
|
|
return do_realtime(ts);
|
|
case CLOCK_MONOTONIC:
|
|
return do_monotonic(ts);
|
|
}
|
|
return vdso_fallback_gettime(clock, ts);
|
|
}
|
|
int clock_gettime(clockid_t, struct timespec *)
|
|
__attribute__((weak, alias("__vdso_clock_gettime")));
|
|
|
|
int __vdso_gettimeofday(struct timeval *tv, struct timezone *tz)
|
|
{
|
|
long ret;
|
|
if (likely(gtod->sysctl_enabled && gtod->clock.vread)) {
|
|
BUILD_BUG_ON(offsetof(struct timeval, tv_usec) !=
|
|
offsetof(struct timespec, tv_nsec) ||
|
|
sizeof(*tv) != sizeof(struct timespec));
|
|
do_realtime((struct timespec *)tv);
|
|
tv->tv_usec /= 1000;
|
|
if (unlikely(tz != NULL)) {
|
|
/* This relies on gcc inlining the memcpy. We'll notice
|
|
if it ever fails to do so. */
|
|
memcpy(tz, >od->sys_tz, sizeof(struct timezone));
|
|
}
|
|
return 0;
|
|
}
|
|
asm("syscall" : "=a" (ret) :
|
|
"0" (__NR_gettimeofday), "D" (tv), "S" (tz) : "memory");
|
|
return ret;
|
|
}
|
|
int gettimeofday(struct timeval *, struct timezone *)
|
|
__attribute__((weak, alias("__vdso_gettimeofday")));
|