1 /*
2 * KVM in-kernel PIT (i8254) support
3 *
4 * Copyright (c) 2003-2004 Fabrice Bellard
5 * Copyright (c) 2012 Jan Kiszka, Siemens AG
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23 * THE SOFTWARE.
24 */
25
26 #include "qemu/osdep.h"
27 #include <linux/kvm.h>
28 #include "qapi/qapi-types-machine.h"
29 #include "qapi/error.h"
30 #include "qemu/module.h"
31 #include "qemu/timer.h"
32 #include "sysemu/runstate.h"
33 #include "hw/timer/i8254.h"
34 #include "hw/timer/i8254_internal.h"
35 #include "hw/qdev-properties-system.h"
36 #include "sysemu/kvm.h"
37 #include "target/i386/kvm/kvm_i386.h"
38 #include "qom/object.h"
39
40 #define KVM_PIT_REINJECT_BIT 0
41
42 #define CALIBRATION_ROUNDS 3
43
44 typedef struct KVMPITClass KVMPITClass;
45 typedef struct KVMPITState KVMPITState;
46 DECLARE_OBJ_CHECKERS(KVMPITState, KVMPITClass,
47 KVM_PIT, TYPE_KVM_I8254)
48
49 struct KVMPITState {
50 PITCommonState parent_obj;
51
52 LostTickPolicy lost_tick_policy;
53 bool vm_stopped;
54 int64_t kernel_clock_offset;
55 };
56
57 struct KVMPITClass {
58 PITCommonClass parent_class;
59
60 DeviceRealize parent_realize;
61 };
62
kvm_pit_update_clock_offset(KVMPITState * s)63 static void kvm_pit_update_clock_offset(KVMPITState *s)
64 {
65 int64_t offset, clock_offset;
66 struct timespec ts;
67 int i;
68
69 /*
70 * Measure the delta between CLOCK_MONOTONIC, the base used for
71 * kvm_pit_channel_state::count_load_time, and QEMU_CLOCK_VIRTUAL. Take the
72 * minimum of several samples to filter out scheduling noise.
73 */
74 clock_offset = INT64_MAX;
75 for (i = 0; i < CALIBRATION_ROUNDS; i++) {
76 offset = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
77 clock_gettime(CLOCK_MONOTONIC, &ts);
78 offset -= ts.tv_nsec;
79 offset -= (int64_t)ts.tv_sec * 1000000000;
80 if (uabs64(offset) < uabs64(clock_offset)) {
81 clock_offset = offset;
82 }
83 }
84 s->kernel_clock_offset = clock_offset;
85 }
86
kvm_pit_get(PITCommonState * pit)87 static void kvm_pit_get(PITCommonState *pit)
88 {
89 KVMPITState *s = KVM_PIT(pit);
90 struct kvm_pit_state2 kpit;
91 struct kvm_pit_channel_state *kchan;
92 struct PITChannelState *sc;
93 int i, ret;
94
95 /* No need to re-read the state if VM is stopped. */
96 if (s->vm_stopped) {
97 return;
98 }
99
100 ret = kvm_vm_ioctl(kvm_state, KVM_GET_PIT2, &kpit);
101 if (ret < 0) {
102 fprintf(stderr, "KVM_GET_PIT2 failed: %s\n", strerror(-ret));
103 abort();
104 }
105 pit->channels[0].irq_disabled = kpit.flags & KVM_PIT_FLAGS_HPET_LEGACY;
106 for (i = 0; i < 3; i++) {
107 kchan = &kpit.channels[i];
108 sc = &pit->channels[i];
109 sc->count = kchan->count;
110 sc->latched_count = kchan->latched_count;
111 sc->count_latched = kchan->count_latched;
112 sc->status_latched = kchan->status_latched;
113 sc->status = kchan->status;
114 sc->read_state = kchan->read_state;
115 sc->write_state = kchan->write_state;
116 sc->write_latch = kchan->write_latch;
117 sc->rw_mode = kchan->rw_mode;
118 sc->mode = kchan->mode;
119 sc->bcd = kchan->bcd;
120 sc->gate = kchan->gate;
121 sc->count_load_time = kchan->count_load_time + s->kernel_clock_offset;
122 }
123
124 sc = &pit->channels[0];
125 sc->next_transition_time =
126 pit_get_next_transition_time(sc, sc->count_load_time);
127 }
128
kvm_pit_put(PITCommonState * pit)129 static void kvm_pit_put(PITCommonState *pit)
130 {
131 KVMPITState *s = KVM_PIT(pit);
132 struct kvm_pit_state2 kpit = {};
133 struct kvm_pit_channel_state *kchan;
134 struct PITChannelState *sc;
135 int i, ret;
136
137 /* The offset keeps changing as long as the VM is stopped. */
138 if (s->vm_stopped) {
139 kvm_pit_update_clock_offset(s);
140 }
141
142 kpit.flags = pit->channels[0].irq_disabled ? KVM_PIT_FLAGS_HPET_LEGACY : 0;
143 for (i = 0; i < 3; i++) {
144 kchan = &kpit.channels[i];
145 sc = &pit->channels[i];
146 kchan->count = sc->count;
147 kchan->latched_count = sc->latched_count;
148 kchan->count_latched = sc->count_latched;
149 kchan->status_latched = sc->status_latched;
150 kchan->status = sc->status;
151 kchan->read_state = sc->read_state;
152 kchan->write_state = sc->write_state;
153 kchan->write_latch = sc->write_latch;
154 kchan->rw_mode = sc->rw_mode;
155 kchan->mode = sc->mode;
156 kchan->bcd = sc->bcd;
157 kchan->gate = sc->gate;
158 kchan->count_load_time = sc->count_load_time - s->kernel_clock_offset;
159 }
160
161 ret = kvm_vm_ioctl(kvm_state, KVM_SET_PIT2, &kpit);
162 if (ret < 0) {
163 fprintf(stderr, "KVM_SET_PIT2 failed: %s\n",
164 strerror(-ret));
165 abort();
166 }
167 }
168
kvm_pit_set_gate(PITCommonState * s,PITChannelState * sc,int val)169 static void kvm_pit_set_gate(PITCommonState *s, PITChannelState *sc, int val)
170 {
171 kvm_pit_get(s);
172
173 switch (sc->mode) {
174 default:
175 case 0:
176 case 4:
177 /* XXX: just disable/enable counting */
178 break;
179 case 1:
180 case 2:
181 case 3:
182 case 5:
183 if (sc->gate < val) {
184 /* restart counting on rising edge */
185 sc->count_load_time = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
186 }
187 break;
188 }
189 sc->gate = val;
190
191 kvm_pit_put(s);
192 }
193
kvm_pit_get_channel_info(PITCommonState * s,PITChannelState * sc,PITChannelInfo * info)194 static void kvm_pit_get_channel_info(PITCommonState *s, PITChannelState *sc,
195 PITChannelInfo *info)
196 {
197 kvm_pit_get(s);
198
199 pit_get_channel_info_common(s, sc, info);
200 }
201
kvm_pit_reset(DeviceState * dev)202 static void kvm_pit_reset(DeviceState *dev)
203 {
204 PITCommonState *s = PIT_COMMON(dev);
205
206 pit_reset_common(s);
207
208 kvm_pit_put(s);
209 }
210
kvm_pit_irq_control(void * opaque,int n,int enable)211 static void kvm_pit_irq_control(void *opaque, int n, int enable)
212 {
213 PITCommonState *pit = opaque;
214 PITChannelState *s = &pit->channels[0];
215
216 kvm_pit_get(pit);
217
218 s->irq_disabled = !enable;
219
220 kvm_pit_put(pit);
221 }
222
kvm_pit_vm_state_change(void * opaque,bool running,RunState state)223 static void kvm_pit_vm_state_change(void *opaque, bool running,
224 RunState state)
225 {
226 KVMPITState *s = opaque;
227
228 if (running) {
229 kvm_pit_update_clock_offset(s);
230 kvm_pit_put(PIT_COMMON(s));
231 s->vm_stopped = false;
232 } else {
233 kvm_pit_update_clock_offset(s);
234 kvm_pit_get(PIT_COMMON(s));
235 s->vm_stopped = true;
236 }
237 }
238
kvm_pit_realizefn(DeviceState * dev,Error ** errp)239 static void kvm_pit_realizefn(DeviceState *dev, Error **errp)
240 {
241 PITCommonState *pit = PIT_COMMON(dev);
242 KVMPITClass *kpc = KVM_PIT_GET_CLASS(dev);
243 KVMPITState *s = KVM_PIT(pit);
244 struct kvm_pit_config config = {
245 .flags = 0,
246 };
247 int ret;
248
249 if (!kvm_check_extension(kvm_state, KVM_CAP_PIT_STATE2) ||
250 !kvm_check_extension(kvm_state, KVM_CAP_PIT2)) {
251 error_setg(errp, "In-kernel PIT not available");
252 }
253
254 ret = kvm_vm_ioctl(kvm_state, KVM_CREATE_PIT2, &config);
255 if (ret < 0) {
256 error_setg(errp, "Create kernel PIC irqchip failed: %s",
257 strerror(-ret));
258 return;
259 }
260 switch (s->lost_tick_policy) {
261 case LOST_TICK_POLICY_DELAY:
262 break; /* enabled by default */
263 case LOST_TICK_POLICY_DISCARD:
264 if (kvm_check_extension(kvm_state, KVM_CAP_REINJECT_CONTROL)) {
265 struct kvm_reinject_control control = { .pit_reinject = 0 };
266
267 ret = kvm_vm_ioctl(kvm_state, KVM_REINJECT_CONTROL, &control);
268 if (ret < 0) {
269 error_setg(errp,
270 "Can't disable in-kernel PIT reinjection: %s",
271 strerror(-ret));
272 return;
273 }
274 }
275 break;
276 default:
277 error_setg(errp, "Lost tick policy not supported.");
278 return;
279 }
280
281 memory_region_init_io(&pit->ioports, OBJECT(dev), NULL, NULL, "kvm-pit", 4);
282
283 qdev_init_gpio_in(dev, kvm_pit_irq_control, 1);
284
285 qemu_add_vm_change_state_handler(kvm_pit_vm_state_change, s);
286
287 kpc->parent_realize(dev, errp);
288 }
289
290 static Property kvm_pit_properties[] = {
291 DEFINE_PROP_LOSTTICKPOLICY("lost_tick_policy", KVMPITState,
292 lost_tick_policy, LOST_TICK_POLICY_DELAY),
293 DEFINE_PROP_END_OF_LIST(),
294 };
295
kvm_pit_class_init(ObjectClass * klass,void * data)296 static void kvm_pit_class_init(ObjectClass *klass, void *data)
297 {
298 KVMPITClass *kpc = KVM_PIT_CLASS(klass);
299 PITCommonClass *k = PIT_COMMON_CLASS(klass);
300 DeviceClass *dc = DEVICE_CLASS(klass);
301
302 device_class_set_parent_realize(dc, kvm_pit_realizefn,
303 &kpc->parent_realize);
304 k->set_channel_gate = kvm_pit_set_gate;
305 k->get_channel_info = kvm_pit_get_channel_info;
306 device_class_set_legacy_reset(dc, kvm_pit_reset);
307 device_class_set_props(dc, kvm_pit_properties);
308 }
309
310 static const TypeInfo kvm_pit_info = {
311 .name = TYPE_KVM_I8254,
312 .parent = TYPE_PIT_COMMON,
313 .instance_size = sizeof(KVMPITState),
314 .class_init = kvm_pit_class_init,
315 .class_size = sizeof(KVMPITClass),
316 };
317
kvm_pit_register(void)318 static void kvm_pit_register(void)
319 {
320 type_register_static(&kvm_pit_info);
321 }
322
323 type_init(kvm_pit_register)
324