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; |
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"); |