Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 28b1a824 authored by Vincenzo Frascino's avatar Vincenzo Frascino Committed by Thomas Gleixner
Browse files

arm64: vdso: Substitute gettimeofday() with C implementation 



To take advantage of the commonly defined vdso interface for gettimeofday()
the architectural code requires an adaptation.

Re-implement the gettimeofday VDSO in C in order to use lib/vdso.

With the new implementation arm64 gains support for CLOCK_BOOTTIME
and CLOCK_TAI.

[ tglx: Reformatted the function line breaks ]

Signed-off-by: default avatarVincenzo Frascino <vincenzo.frascino@arm.com>
Signed-off-by: default avatarThomas Gleixner <tglx@linutronix.de>
Tested-by: default avatarShijith Thotton <sthotton@marvell.com>
Tested-by: default avatarAndre Przywara <andre.przywara@arm.com>
Cc: linux-arch@vger.kernel.org
Cc: linux-arm-kernel@lists.infradead.org
Cc: linux-mips@vger.kernel.org
Cc: linux-kselftest@vger.kernel.org
Cc: Catalin Marinas <catalin.marinas@arm.com>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Arnd Bergmann <arnd@arndb.de>
Cc: Russell King <linux@armlinux.org.uk>
Cc: Ralf Baechle <ralf@linux-mips.org>
Cc: Paul Burton <paul.burton@mips.com>
Cc: Daniel Lezcano <daniel.lezcano@linaro.org>
Cc: Mark Salyzyn <salyzyn@android.com>
Cc: Peter Collingbourne <pcc@google.com>
Cc: Shuah Khan <shuah@kernel.org>
Cc: Dmitry Safonov <0x7f454c46@gmail.com>
Cc: Rasmus Villemoes <linux@rasmusvillemoes.dk>
Cc: Huw Davies <huw@codeweavers.com>
Link: https://lkml.kernel.org/r/20190621095252.32307-5-vincenzo.frascino@arm.com
parent 44f57d78

arch/arm64/Kconfig

+2 −0
Original line number Diff line number Diff line
@@ -107,6 +107,7 @@ config ARM64 
	select GENERIC_STRNCPY_FROM_USER

	select GENERIC_STRNLEN_USER

	select GENERIC_TIME_VSYSCALL

	select GENERIC_GETTIMEOFDAY

	select HANDLE_DOMAIN_IRQ

	select HARDIRQS_SW_RESEND

	select HAVE_PCI
@@ -160,6 +161,7 @@ config ARM64 
	select HAVE_SYSCALL_TRACEPOINTS

	select HAVE_KPROBES

	select HAVE_KRETPROBES

	select HAVE_GENERIC_VDSO

	select IOMMU_DMA if IOMMU_SUPPORT

	select IRQ_DOMAIN

	select IRQ_FORCED_THREADING

arch/arm64/include/asm/vdso/gettimeofday.h

0 → 100644
+84 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0 */

/*

 * Copyright (C) 2018 ARM Limited

 */

#ifndef __ASM_VDSO_GETTIMEOFDAY_H

#define __ASM_VDSO_GETTIMEOFDAY_H



#ifndef __ASSEMBLY__



#include <asm/unistd.h>

#include <uapi/linux/time.h>



#define VDSO_HAS_CLOCK_GETRES		1



static __always_inline

int gettimeofday_fallback(struct __kernel_old_timeval *_tv,

			  struct timezone *_tz)

{

	register struct timezone *tz asm("x1") = _tz;

	register struct __kernel_old_timeval *tv asm("x0") = _tv;

	register long ret asm ("x0");

	register long nr asm("x8") = __NR_gettimeofday;



	asm volatile(

	"       svc #0\n"

	: "=r" (ret)

	: "r" (tv), "r" (tz), "r" (nr)

	: "memory");



	return ret;

}



static __always_inline

long clock_gettime_fallback(clockid_t _clkid, struct __kernel_timespec *_ts)

{

	register struct __kernel_timespec *ts asm("x1") = _ts;

	register clockid_t clkid asm("x0") = _clkid;

	register long ret asm ("x0");

	register long nr asm("x8") = __NR_clock_gettime;



	asm volatile(

	"       svc #0\n"

	: "=r" (ret)

	: "r" (clkid), "r" (ts), "r" (nr)

	: "memory");



	return ret;

}



static __always_inline

int clock_getres_fallback(clockid_t _clkid, struct __kernel_timespec *_ts)

{

	register struct __kernel_timespec *ts asm("x1") = _ts;

	register clockid_t clkid asm("x0") = _clkid;

	register long ret asm ("x0");

	register long nr asm("x8") = __NR_clock_getres;



	asm volatile(

	"       svc #0\n"

	: "=r" (ret)

	: "r" (clkid), "r" (ts), "r" (nr)

	: "memory");



	return ret;

}



static __always_inline u64 __arch_get_hw_counter(s32 clock_mode)

{

	u64 res;



	asm volatile("mrs %0, cntvct_el0" : "=r" (res) :: "memory");



	return res;

}



static __always_inline

const struct vdso_data *__arch_get_vdso_data(void)

{

	return _vdso_data;

}



#endif /* !__ASSEMBLY__ */



#endif /* __ASM_VDSO_GETTIMEOFDAY_H */

arch/arm64/include/asm/vdso/vsyscall.h

0 → 100644
+53 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0 */

#ifndef __ASM_VDSO_VSYSCALL_H

#define __ASM_VDSO_VSYSCALL_H



#ifndef __ASSEMBLY__



#include <linux/timekeeper_internal.h>

#include <vdso/datapage.h>



#define VDSO_PRECISION_MASK	~(0xFF00ULL<<48)



extern struct vdso_data *vdso_data;



/*

 * Update the vDSO data page to keep in sync with kernel timekeeping.

 */

static __always_inline

struct vdso_data *__arm64_get_k_vdso_data(void)

{

	return vdso_data;

}

#define __arch_get_k_vdso_data __arm64_get_k_vdso_data



static __always_inline

int __arm64_get_clock_mode(struct timekeeper *tk)

{

	u32 use_syscall = !tk->tkr_mono.clock->archdata.vdso_direct;



	return use_syscall;

}

#define __arch_get_clock_mode __arm64_get_clock_mode



static __always_inline

int __arm64_use_vsyscall(struct vdso_data *vdata)

{

	return !vdata[CS_HRES_COARSE].clock_mode;

}

#define __arch_use_vsyscall __arm64_use_vsyscall



static __always_inline

void __arm64_update_vsyscall(struct vdso_data *vdata, struct timekeeper *tk)

{

	vdata[CS_HRES_COARSE].mask	= VDSO_PRECISION_MASK;

	vdata[CS_RAW].mask		= VDSO_PRECISION_MASK;

}

#define __arch_update_vsyscall __arm64_update_vsyscall



/* The asm-generic header needs to be included after the definitions above */

#include <asm-generic/vdso/vsyscall.h>



#endif /* !__ASSEMBLY__ */



#endif /* __ASM_VDSO_VSYSCALL_H */

arch/arm64/kernel/asm-offsets.c

+22 −11
Original line number Diff line number Diff line
@@ -14,13 +14,13 @@ 
#include <linux/kvm_host.h>

#include <linux/preempt.h>

#include <linux/suspend.h>

#include <vdso/datapage.h>

#include <asm/cpufeature.h>

#include <asm/fixmap.h>

#include <asm/thread_info.h>

#include <asm/memory.h>

#include <asm/smp_plat.h>

#include <asm/suspend.h>

#include <asm/vdso_datapage.h>

#include <linux/kbuild.h>

#include <linux/arm-smccc.h>
@@ -89,17 +89,28 @@ int main(void) 
  DEFINE(CLOCK_COARSE_RES,	LOW_RES_NSEC);

  DEFINE(NSEC_PER_SEC,		NSEC_PER_SEC);

  BLANK();

  DEFINE(VDSO_CS_CYCLE_LAST,	offsetof(struct vdso_data, cs_cycle_last));

  DEFINE(VDSO_RAW_TIME_SEC,	offsetof(struct vdso_data, raw_time_sec));

  DEFINE(VDSO_XTIME_CLK_SEC,	offsetof(struct vdso_data, xtime_clock_sec));

  DEFINE(VDSO_XTIME_CRS_SEC,	offsetof(struct vdso_data, xtime_coarse_sec));

  DEFINE(VDSO_XTIME_CRS_NSEC,	offsetof(struct vdso_data, xtime_coarse_nsec));

  DEFINE(VDSO_WTM_CLK_SEC,	offsetof(struct vdso_data, wtm_clock_sec));

  DEFINE(VDSO_TB_SEQ_COUNT,	offsetof(struct vdso_data, tb_seq_count));

  DEFINE(VDSO_CS_MONO_MULT,	offsetof(struct vdso_data, cs_mono_mult));

  DEFINE(VDSO_CS_SHIFT,		offsetof(struct vdso_data, cs_shift));

  DEFINE(VDSO_SEQ,		offsetof(struct vdso_data, seq));

  DEFINE(VDSO_CLK_MODE,		offsetof(struct vdso_data, clock_mode));

  DEFINE(VDSO_CYCLE_LAST,	offsetof(struct vdso_data, cycle_last));

  DEFINE(VDSO_MASK,		offsetof(struct vdso_data, mask));

  DEFINE(VDSO_MULT,		offsetof(struct vdso_data, mult));

  DEFINE(VDSO_SHIFT,		offsetof(struct vdso_data, shift));

  DEFINE(VDSO_REALTIME_SEC,	offsetof(struct vdso_data, basetime[CLOCK_REALTIME].sec));

  DEFINE(VDSO_REALTIME_NSEC,	offsetof(struct vdso_data, basetime[CLOCK_REALTIME].nsec));

  DEFINE(VDSO_MONO_SEC,		offsetof(struct vdso_data, basetime[CLOCK_MONOTONIC].sec));

  DEFINE(VDSO_MONO_NSEC,	offsetof(struct vdso_data, basetime[CLOCK_MONOTONIC].nsec));

  DEFINE(VDSO_MONO_RAW_SEC,	offsetof(struct vdso_data, basetime[CLOCK_MONOTONIC_RAW].sec));

  DEFINE(VDSO_MONO_RAW_NSEC,	offsetof(struct vdso_data, basetime[CLOCK_MONOTONIC_RAW].nsec));

  DEFINE(VDSO_BOOTTIME_SEC,	offsetof(struct vdso_data, basetime[CLOCK_BOOTTIME].sec));

  DEFINE(VDSO_BOOTTIME_NSEC,	offsetof(struct vdso_data, basetime[CLOCK_BOOTTIME].nsec));

  DEFINE(VDSO_TAI_SEC,		offsetof(struct vdso_data, basetime[CLOCK_TAI].sec));

  DEFINE(VDSO_TAI_NSEC,		offsetof(struct vdso_data, basetime[CLOCK_TAI].nsec));

  DEFINE(VDSO_RT_COARSE_SEC,	offsetof(struct vdso_data, basetime[CLOCK_REALTIME_COARSE].sec));

  DEFINE(VDSO_RT_COARSE_NSEC,	offsetof(struct vdso_data, basetime[CLOCK_REALTIME_COARSE].nsec));

  DEFINE(VDSO_MONO_COARSE_SEC,	offsetof(struct vdso_data, basetime[CLOCK_MONOTONIC_COARSE].sec));

  DEFINE(VDSO_MONO_COARSE_NSEC,	offsetof(struct vdso_data, basetime[CLOCK_MONOTONIC_COARSE].nsec));

  DEFINE(VDSO_TZ_MINWEST,	offsetof(struct vdso_data, tz_minuteswest));

  DEFINE(VDSO_USE_SYSCALL,	offsetof(struct vdso_data, use_syscall));

  DEFINE(VDSO_TZ_DSTTIME,	offsetof(struct vdso_data, tz_dsttime));

  BLANK();

  DEFINE(TVAL_TV_SEC,		offsetof(struct timeval, tv_sec));

  DEFINE(TSPEC_TV_SEC,		offsetof(struct timespec, tv_sec));

arch/arm64/kernel/vdso.c

+5 −46
Original line number Diff line number Diff line
@@ -20,11 +20,13 @@ 
#include <linux/slab.h>

#include <linux/timekeeper_internal.h>

#include <linux/vmalloc.h>

#include <vdso/datapage.h>

#include <vdso/helpers.h>

#include <vdso/vsyscall.h>



#include <asm/cacheflush.h>

#include <asm/signal32.h>

#include <asm/vdso.h>

#include <asm/vdso_datapage.h>



extern char vdso_start[], vdso_end[];

static unsigned long vdso_pages __ro_after_init;
@@ -33,10 +35,10 @@ static unsigned long vdso_pages __ro_after_init; 
 * The vDSO data page.

 */

static union {

	struct vdso_data	data;

	struct vdso_data	data[CS_BASES];

	u8			page[PAGE_SIZE];

} vdso_data_store __page_aligned_data;

struct vdso_data *vdso_data = &vdso_data_store.data;

struct vdso_data *vdso_data = vdso_data_store.data;



#ifdef CONFIG_COMPAT

/*
@@ -269,46 +271,3 @@ int arch_setup_additional_pages(struct linux_binprm *bprm, 
	up_write(&mm->mmap_sem);

	return PTR_ERR(ret);

}
 


/*

 * Update the vDSO data page to keep in sync with kernel timekeeping.

 */

void update_vsyscall(struct timekeeper *tk)

{

	u32 use_syscall = !tk->tkr_mono.clock->archdata.vdso_direct;



	++vdso_data->tb_seq_count;

	smp_wmb();



	vdso_data->use_syscall			= use_syscall;

	vdso_data->xtime_coarse_sec		= tk->xtime_sec;

	vdso_data->xtime_coarse_nsec		= tk->tkr_mono.xtime_nsec >>

							tk->tkr_mono.shift;

	vdso_data->wtm_clock_sec		= tk->wall_to_monotonic.tv_sec;

	vdso_data->wtm_clock_nsec		= tk->wall_to_monotonic.tv_nsec;



	/* Read without the seqlock held by clock_getres() */

	WRITE_ONCE(vdso_data->hrtimer_res, hrtimer_resolution);



	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_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;

		vdso_data->cs_raw_mult		= tk->tkr_raw.mult;

		/* tkr_mono.shift == tkr_raw.shift */

		vdso_data->cs_shift		= tk->tkr_mono.shift;

	}



	smp_wmb();

	++vdso_data->tb_seq_count;

}



void update_vsyscall_tz(void)

{

	vdso_data->tz_minuteswest	= sys_tz.tz_minuteswest;

	vdso_data->tz_dsttime		= sys_tz.tz_dsttime;

}