[linux-2.6-block.git] / drivers / ptp / ptp_kvm.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Virtual PTP 1588 clock for use with KVM guests
 *
 * Copyright (C) 2017 Red Hat Inc.
 */
#include <linux/device.h>
#include <linux/err.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <uapi/linux/kvm_para.h>
#include <asm/kvm_para.h>
#include <asm/pvclock.h>
#include <asm/kvmclock.h>
#include <uapi/asm/kvm_para.h>

#include <linux/ptp_clock_kernel.h>

struct kvm_ptp_clock {
	struct ptp_clock *ptp_clock;
	struct ptp_clock_info caps;
};

DEFINE_SPINLOCK(kvm_ptp_lock);

static struct pvclock_vsyscall_time_info *hv_clock;

static struct kvm_clock_pairing clock_pair;
static phys_addr_t clock_pair_gpa;

static int ptp_kvm_get_time_fn(ktime_t *device_time,
			       struct system_counterval_t *system_counter,
			       void *ctx)
{
	unsigned long ret;
	struct timespec64 tspec;
	unsigned version;
	int cpu;
	struct pvclock_vcpu_time_info *src;

	spin_lock(&kvm_ptp_lock);

	preempt_disable_notrace();
	cpu = smp_processor_id();
	src = &hv_clock[cpu].pvti;

	do {
		/*
		 * We are using a TSC value read in the hosts
		 * kvm_hc_clock_pairing handling.
		 * So any changes to tsc_to_system_mul
		 * and tsc_shift or any other pvclock
		 * data invalidate that measurement.
		 */
		version = pvclock_read_begin(src);

		ret = kvm_hypercall2(KVM_HC_CLOCK_PAIRING,
				     clock_pair_gpa,
				     KVM_CLOCK_PAIRING_WALLCLOCK);
		if (ret != 0) {
			pr_err_ratelimited("clock pairing hypercall ret %lu\n", ret);
			spin_unlock(&kvm_ptp_lock);
			preempt_enable_notrace();
			return -EOPNOTSUPP;
		}

		tspec.tv_sec = clock_pair.sec;
		tspec.tv_nsec = clock_pair.nsec;
		ret = __pvclock_read_cycles(src, clock_pair.tsc);
	} while (pvclock_read_retry(src, version));

	preempt_enable_notrace();

	system_counter->cycles = ret;
	system_counter->cs = &kvm_clock;

	*device_time = timespec64_to_ktime(tspec);

	spin_unlock(&kvm_ptp_lock);

	return 0;
}

static int ptp_kvm_getcrosststamp(struct ptp_clock_info *ptp,
				  struct system_device_crosststamp *xtstamp)
{
	return get_device_system_crosststamp(ptp_kvm_get_time_fn, NULL,
					     NULL, xtstamp);
}

/*
 * PTP clock operations
 */

static int ptp_kvm_adjfreq(struct ptp_clock_info *ptp, s32 ppb)
{
	return -EOPNOTSUPP;
}

static int ptp_kvm_adjtime(struct ptp_clock_info *ptp, s64 delta)
{
	return -EOPNOTSUPP;
}

static int ptp_kvm_settime(struct ptp_clock_info *ptp,
			   const struct timespec64 *ts)
{
	return -EOPNOTSUPP;
}

static int ptp_kvm_gettime(struct ptp_clock_info *ptp, struct timespec64 *ts)
{
	unsigned long ret;
	struct timespec64 tspec;

	spin_lock(&kvm_ptp_lock);

	ret = kvm_hypercall2(KVM_HC_CLOCK_PAIRING,
			     clock_pair_gpa,
			     KVM_CLOCK_PAIRING_WALLCLOCK);
	if (ret != 0) {
		pr_err_ratelimited("clock offset hypercall ret %lu\n", ret);
		spin_unlock(&kvm_ptp_lock);
		return -EOPNOTSUPP;
	}

	tspec.tv_sec = clock_pair.sec;
	tspec.tv_nsec = clock_pair.nsec;
	spin_unlock(&kvm_ptp_lock);

	memcpy(ts, &tspec, sizeof(struct timespec64));

	return 0;
}

static int ptp_kvm_enable(struct ptp_clock_info *ptp,
			  struct ptp_clock_request *rq, int on)
{
	return -EOPNOTSUPP;
}

static const struct ptp_clock_info ptp_kvm_caps = {
	.owner		= THIS_MODULE,
	.name		= "KVM virtual PTP",
	.max_adj	= 0,
	.n_ext_ts	= 0,
	.n_pins		= 0,
	.pps		= 0,
	.adjfreq	= ptp_kvm_adjfreq,
	.adjtime	= ptp_kvm_adjtime,
	.gettime64	= ptp_kvm_gettime,
	.settime64	= ptp_kvm_settime,
	.enable		= ptp_kvm_enable,
	.getcrosststamp = ptp_kvm_getcrosststamp,
};

/* module operations */

static struct kvm_ptp_clock kvm_ptp_clock;

static void __exit ptp_kvm_exit(void)
{
	ptp_clock_unregister(kvm_ptp_clock.ptp_clock);
}

static int __init ptp_kvm_init(void)
{
	long ret;

	if (!kvm_para_available())
		return -ENODEV;

	clock_pair_gpa = slow_virt_to_phys(&clock_pair);
	hv_clock = pvclock_get_pvti_cpu0_va();

	if (!hv_clock)
		return -ENODEV;

	ret = kvm_hypercall2(KVM_HC_CLOCK_PAIRING, clock_pair_gpa,
			KVM_CLOCK_PAIRING_WALLCLOCK);
	if (ret == -KVM_ENOSYS || ret == -KVM_EOPNOTSUPP)
		return -ENODEV;

	kvm_ptp_clock.caps = ptp_kvm_caps;

	kvm_ptp_clock.ptp_clock = ptp_clock_register(&kvm_ptp_clock.caps, NULL);

	return PTR_ERR_OR_ZERO(kvm_ptp_clock.ptp_clock);
}

module_init(ptp_kvm_init);
module_exit(ptp_kvm_exit);

MODULE_AUTHOR("Marcelo Tosatti <mtosatti@redhat.com>");
MODULE_DESCRIPTION("PTP clock using KVMCLOCK");
MODULE_LICENSE("GPL");
Commit	Line	Data
c942fddf	1	// SPDX-License-Identifier: GPL-2.0-or-later
a0e136d4 MT	2	/*
	3	* Virtual PTP 1588 clock for use with KVM guests
	4	*
	5	* Copyright (C) 2017 Red Hat Inc.
a0e136d4 MT	6	*/
	7	#include <linux/device.h>
	8	#include <linux/err.h>
	9	#include <linux/init.h>
	10	#include <linux/kernel.h>
	11	#include <linux/module.h>
	12	#include <uapi/linux/kvm_para.h>
	13	#include <asm/kvm_para.h>
	14	#include <asm/pvclock.h>
	15	#include <asm/kvmclock.h>
	16	#include <uapi/asm/kvm_para.h>
	17
	18	#include <linux/ptp_clock_kernel.h>
	19
	20	struct kvm_ptp_clock {
	21	struct ptp_clock *ptp_clock;
	22	struct ptp_clock_info caps;
	23	};
	24
	25	DEFINE_SPINLOCK(kvm_ptp_lock);
	26
	27	static struct pvclock_vsyscall_time_info *hv_clock;
	28
	29	static struct kvm_clock_pairing clock_pair;
	30	static phys_addr_t clock_pair_gpa;
	31
	32	static int ptp_kvm_get_time_fn(ktime_t *device_time,
	33	struct system_counterval_t *system_counter,
	34	void *ctx)
	35	{
	36	unsigned long ret;
	37	struct timespec64 tspec;
	38	unsigned version;
	39	int cpu;
	40	struct pvclock_vcpu_time_info *src;
	41
	42	spin_lock(&kvm_ptp_lock);
	43
	44	preempt_disable_notrace();
	45	cpu = smp_processor_id();
	46	src = &hv_clock[cpu].pvti;
	47
	48	do {
	49	/*
	50	* We are using a TSC value read in the hosts
	51	* kvm_hc_clock_pairing handling.
	52	* So any changes to tsc_to_system_mul
	53	* and tsc_shift or any other pvclock
	54	* data invalidate that measurement.
	55	*/
	56	version = pvclock_read_begin(src);
	57
	58	ret = kvm_hypercall2(KVM_HC_CLOCK_PAIRING,
	59	clock_pair_gpa,
	60	KVM_CLOCK_PAIRING_WALLCLOCK);
	61	if (ret != 0) {
	62	pr_err_ratelimited("clock pairing hypercall ret %lu\n", ret);
	63	spin_unlock(&kvm_ptp_lock);
	64	preempt_enable_notrace();
	65	return -EOPNOTSUPP;
	66	}
	67
	68	tspec.tv_sec = clock_pair.sec;
	69	tspec.tv_nsec = clock_pair.nsec;
70	ret = __pvclock_read_cycles(src, clock_pair.tsc);
71	} while (pvclock_read_retry(src, version));
72
73	preempt_enable_notrace();
74
75	system_counter->cycles = ret;
76	system_counter->cs = &kvm_clock;
77
78	*device_time = timespec64_to_ktime(tspec);
79
80	spin_unlock(&kvm_ptp_lock);
81
82	return 0;
83	}
84
85	static int ptp_kvm_getcrosststamp(struct ptp_clock_info *ptp,
86	struct system_device_crosststamp *xtstamp)
87	{
88	return get_device_system_crosststamp(ptp_kvm_get_time_fn, NULL,
89	NULL, xtstamp);
90	}
91
92	/*
93	* PTP clock operations
94	*/
95
96	static int ptp_kvm_adjfreq(struct ptp_clock_info *ptp, s32 ppb)
97	{
98	return -EOPNOTSUPP;
99	}
100
101	static int ptp_kvm_adjtime(struct ptp_clock_info *ptp, s64 delta)
102	{
103	return -EOPNOTSUPP;
104	}
105
106	static int ptp_kvm_settime(struct ptp_clock_info *ptp,
107	const struct timespec64 *ts)
108	{
109	return -EOPNOTSUPP;
110	}
111
112	static int ptp_kvm_gettime(struct ptp_clock_info ptp, struct timespec64 ts)
113	{
114	unsigned long ret;
115	struct timespec64 tspec;
116
117	spin_lock(&kvm_ptp_lock);
118
119	ret = kvm_hypercall2(KVM_HC_CLOCK_PAIRING,
120	clock_pair_gpa,
121	KVM_CLOCK_PAIRING_WALLCLOCK);
122	if (ret != 0) {
123	pr_err_ratelimited("clock offset hypercall ret %lu\n", ret);
124	spin_unlock(&kvm_ptp_lock);
125	return -EOPNOTSUPP;
126	}
127
128	tspec.tv_sec = clock_pair.sec;
129	tspec.tv_nsec = clock_pair.nsec;
130	spin_unlock(&kvm_ptp_lock);
131
132	memcpy(ts, &tspec, sizeof(struct timespec64));
133
134	return 0;
135	}
136
137	static int ptp_kvm_enable(struct ptp_clock_info *ptp,
138	struct ptp_clock_request *rq, int on)
139	{
140	return -EOPNOTSUPP;
141	}
142
7d47e9a2	143	static const struct ptp_clock_info ptp_kvm_caps = {
a0e136d4 MT	144	.owner = THIS_MODULE,
	145	.name = "KVM virtual PTP",
	146	.max_adj = 0,
	147	.n_ext_ts = 0,
	148	.n_pins = 0,
	149	.pps = 0,
	150	.adjfreq = ptp_kvm_adjfreq,
	151	.adjtime = ptp_kvm_adjtime,
	152	.gettime64 = ptp_kvm_gettime,
	153	.settime64 = ptp_kvm_settime,
	154	.enable = ptp_kvm_enable,
	155	.getcrosststamp = ptp_kvm_getcrosststamp,
	156	};
	157
	158	/* module operations */
	159
	160	static struct kvm_ptp_clock kvm_ptp_clock;
	161
	162	static void __exit ptp_kvm_exit(void)
	163	{
	164	ptp_clock_unregister(kvm_ptp_clock.ptp_clock);
	165	}
	166
	167	static int __init ptp_kvm_init(void)
	168	{
4306f200 RK	169	long ret;
4306f200 RK	170
001f60e1 JM	171	if (!kvm_para_available())
	172	return -ENODEV;
	173
a0e136d4	174	clock_pair_gpa = slow_virt_to_phys(&clock_pair);
9f08890a	175	hv_clock = pvclock_get_pvti_cpu0_va();
a0e136d4 MT	176
	177	if (!hv_clock)
	178	return -ENODEV;
	179
4306f200 RK	180	ret = kvm_hypercall2(KVM_HC_CLOCK_PAIRING, clock_pair_gpa,
	181	KVM_CLOCK_PAIRING_WALLCLOCK);
	182	if (ret == -KVM_ENOSYS \|\| ret == -KVM_EOPNOTSUPP)
	183	return -ENODEV;
	184
a0e136d4 MT	185	kvm_ptp_clock.caps = ptp_kvm_caps;
	186
	187	kvm_ptp_clock.ptp_clock = ptp_clock_register(&kvm_ptp_clock.caps, NULL);
	188
49e190ec	189	return PTR_ERR_OR_ZERO(kvm_ptp_clock.ptp_clock);
a0e136d4 MT	190	}
	191
	192	module_init(ptp_kvm_init);
	193	module_exit(ptp_kvm_exit);
	194
	195	MODULE_AUTHOR("Marcelo Tosatti <mtosatti@redhat.com>");
	196	MODULE_DESCRIPTION("PTP clock using KVMCLOCK");
	197	MODULE_LICENSE("GPL");