/* SPDX-License-Identifier: GPL-2.0 */ /* * Fast user context implementation of clock_gettime, gettimeofday, and time. * * Copyright (C) 2019 ARM Limited. * Copyright 2006 Andi Kleen, SUSE Labs. * 32 Bit compat layer by Stefani Seibold <[email protected]> * sponsored by Rohde & Schwarz GmbH & Co. KG Munich/Germany */ #ifndef __ASM_VDSO_GETTIMEOFDAY_H #define __ASM_VDSO_GETTIMEOFDAY_H #ifndef __ASSEMBLY__ #include <uapi/linux/time.h> #include <asm/vgtod.h> #include <asm/vvar.h> #include <asm/unistd.h> #include <asm/msr.h> #include <asm/pvclock.h> #include <clocksource/hyperv_timer.h> #define __vdso_data … #define __timens_vdso_data … #define VDSO_HAS_TIME … #define VDSO_HAS_CLOCK_GETRES … /* * Declare the memory-mapped vclock data pages. These come from hypervisors. * If we ever reintroduce something like direct access to an MMIO clock like * the HPET again, it will go here as well. * * A load from any of these pages will segfault if the clock in question is * disabled, so appropriate compiler barriers and checks need to be used * to prevent stray loads. * * These declarations MUST NOT be const. The compiler will assume that * an extern const variable has genuinely constant contents, and the * resulting code won't work, since the whole point is that these pages * change over time, possibly while we're accessing them. */ #ifdef CONFIG_PARAVIRT_CLOCK /* * This is the vCPU 0 pvclock page. We only use pvclock from the vDSO * if the hypervisor tells us that all vCPUs can get valid data from the * vCPU 0 page. */ extern struct pvclock_vsyscall_time_info pvclock_page __attribute__((hidden)); #endif #ifdef CONFIG_HYPERV_TIMER extern struct ms_hyperv_tsc_page hvclock_page __attribute__((hidden)); #endif #ifdef CONFIG_TIME_NS static __always_inline const struct vdso_data *__arch_get_timens_vdso_data(const struct vdso_data *vd) { … } #endif #ifndef BUILD_VDSO32 static __always_inline long clock_gettime_fallback(clockid_t _clkid, struct __kernel_timespec *_ts) { … } static __always_inline long gettimeofday_fallback(struct __kernel_old_timeval *_tv, struct timezone *_tz) { … } static __always_inline long clock_getres_fallback(clockid_t _clkid, struct __kernel_timespec *_ts) { … } #else static __always_inline long clock_gettime_fallback(clockid_t _clkid, struct __kernel_timespec *_ts) { long ret; asm ( "mov %%ebx, %%edx \n" "mov %[clock], %%ebx \n" "call __kernel_vsyscall \n" "mov %%edx, %%ebx \n" : "=a" (ret), "=m" (*_ts) : "0" (__NR_clock_gettime64), [clock] "g" (_clkid), "c" (_ts) : "edx"); return ret; } static __always_inline long clock_gettime32_fallback(clockid_t _clkid, struct old_timespec32 *_ts) { long ret; asm ( "mov %%ebx, %%edx \n" "mov %[clock], %%ebx \n" "call __kernel_vsyscall \n" "mov %%edx, %%ebx \n" : "=a" (ret), "=m" (*_ts) : "0" (__NR_clock_gettime), [clock] "g" (_clkid), "c" (_ts) : "edx"); return ret; } static __always_inline long gettimeofday_fallback(struct __kernel_old_timeval *_tv, struct timezone *_tz) { long ret; asm( "mov %%ebx, %%edx \n" "mov %2, %%ebx \n" "call __kernel_vsyscall \n" "mov %%edx, %%ebx \n" : "=a" (ret) : "0" (__NR_gettimeofday), "g" (_tv), "c" (_tz) : "memory", "edx"); return ret; } static __always_inline long clock_getres_fallback(clockid_t _clkid, struct __kernel_timespec *_ts) { long ret; asm ( "mov %%ebx, %%edx \n" "mov %[clock], %%ebx \n" "call __kernel_vsyscall \n" "mov %%edx, %%ebx \n" : "=a" (ret), "=m" (*_ts) : "0" (__NR_clock_getres_time64), [clock] "g" (_clkid), "c" (_ts) : "edx"); return ret; } static __always_inline long clock_getres32_fallback(clockid_t _clkid, struct old_timespec32 *_ts) { long ret; asm ( "mov %%ebx, %%edx \n" "mov %[clock], %%ebx \n" "call __kernel_vsyscall \n" "mov %%edx, %%ebx \n" : "=a" (ret), "=m" (*_ts) : "0" (__NR_clock_getres), [clock] "g" (_clkid), "c" (_ts) : "edx"); return ret; } #endif #ifdef CONFIG_PARAVIRT_CLOCK static u64 vread_pvclock(void) { … } #endif #ifdef CONFIG_HYPERV_TIMER static u64 vread_hvclock(void) { … } #endif static inline u64 __arch_get_hw_counter(s32 clock_mode, const struct vdso_data *vd) { … } static __always_inline const struct vdso_data *__arch_get_vdso_data(void) { … } static inline bool arch_vdso_clocksource_ok(const struct vdso_data *vd) { … } #define vdso_clocksource_ok … /* * Clocksource read value validation to handle PV and HyperV clocksources * which can be invalidated asynchronously and indicate invalidation by * returning U64_MAX, which can be effectively tested by checking for a * negative value after casting it to s64. * * This effectively forces a S64_MAX mask on the calculations, unlike the * U64_MAX mask normally used by x86 clocksources. */ static inline bool arch_vdso_cycles_ok(u64 cycles) { … } #define vdso_cycles_ok … /* * x86 specific calculation of nanoseconds for the current cycle count * * The regular implementation assumes that clocksource reads are globally * monotonic. The TSC can be slightly off across sockets which can cause * the regular delta calculation (@cycles - @last) to return a huge time * jump. * * Therefore it needs to be verified that @cycles are greater than * @vd->cycles_last. If not then use @vd->cycles_last, which is the base * time of the current conversion period. * * This variant also uses a custom mask because while the clocksource mask of * all the VDSO capable clocksources on x86 is U64_MAX, the above code uses * U64_MASK as an exception value, additionally arch_vdso_cycles_ok() above * declares everything with the MSB/Sign-bit set as invalid. Therefore the * effective mask is S64_MAX. */ static __always_inline u64 vdso_calc_ns(const struct vdso_data *vd, u64 cycles, u64 base) { … } #define vdso_calc_ns … #endif /* !__ASSEMBLY__ */ #endif /* __ASM_VDSO_GETTIMEOFDAY_H */
Codebase Browser
linux