1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26#include "qemu/osdep.h"
27#include <linux/kvm.h>
28#include "qapi/qapi-types-misc.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 "sysemu/kvm.h"
36
37#define KVM_PIT_REINJECT_BIT 0
38
39#define CALIBRATION_ROUNDS 3
40
41#define KVM_PIT(obj) OBJECT_CHECK(KVMPITState, (obj), TYPE_KVM_I8254)
42#define KVM_PIT_CLASS(class) \
43 OBJECT_CLASS_CHECK(KVMPITClass, (class), TYPE_KVM_I8254)
44#define KVM_PIT_GET_CLASS(obj) \
45 OBJECT_GET_CLASS(KVMPITClass, (obj), TYPE_KVM_I8254)
46
47typedef struct KVMPITState {
48 PITCommonState parent_obj;
49
50 LostTickPolicy lost_tick_policy;
51 bool vm_stopped;
52 int64_t kernel_clock_offset;
53} KVMPITState;
54
55typedef struct KVMPITClass {
56 PITCommonClass parent_class;
57
58 DeviceRealize parent_realize;
59} KVMPITClass;
60
61static int64_t abs64(int64_t v)
62{
63 return v < 0 ? -v : v;
64}
65
66static void kvm_pit_update_clock_offset(KVMPITState *s)
67{
68 int64_t offset, clock_offset;
69 struct timespec ts;
70 int i;
71
72
73
74
75
76
77 clock_offset = INT64_MAX;
78 for (i = 0; i < CALIBRATION_ROUNDS; i++) {
79 offset = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
80 clock_gettime(CLOCK_MONOTONIC, &ts);
81 offset -= ts.tv_nsec;
82 offset -= (int64_t)ts.tv_sec * 1000000000;
83 if (abs64(offset) < abs64(clock_offset)) {
84 clock_offset = offset;
85 }
86 }
87 s->kernel_clock_offset = clock_offset;
88}
89
90static void kvm_pit_get(PITCommonState *pit)
91{
92 KVMPITState *s = KVM_PIT(pit);
93 struct kvm_pit_state2 kpit;
94 struct kvm_pit_channel_state *kchan;
95 struct PITChannelState *sc;
96 int i, ret;
97
98
99 if (s->vm_stopped) {
100 return;
101 }
102
103 if (kvm_has_pit_state2()) {
104 ret = kvm_vm_ioctl(kvm_state, KVM_GET_PIT2, &kpit);
105 if (ret < 0) {
106 fprintf(stderr, "KVM_GET_PIT2 failed: %s\n", strerror(ret));
107 abort();
108 }
109 pit->channels[0].irq_disabled = kpit.flags & KVM_PIT_FLAGS_HPET_LEGACY;
110 } else {
111
112
113
114
115 ret = kvm_vm_ioctl(kvm_state, KVM_GET_PIT, &kpit);
116 if (ret < 0) {
117 fprintf(stderr, "KVM_GET_PIT failed: %s\n", strerror(ret));
118 abort();
119 }
120 }
121 for (i = 0; i < 3; i++) {
122 kchan = &kpit.channels[i];
123 sc = &pit->channels[i];
124 sc->count = kchan->count;
125 sc->latched_count = kchan->latched_count;
126 sc->count_latched = kchan->count_latched;
127 sc->status_latched = kchan->status_latched;
128 sc->status = kchan->status;
129 sc->read_state = kchan->read_state;
130 sc->write_state = kchan->write_state;
131 sc->write_latch = kchan->write_latch;
132 sc->rw_mode = kchan->rw_mode;
133 sc->mode = kchan->mode;
134 sc->bcd = kchan->bcd;
135 sc->gate = kchan->gate;
136 sc->count_load_time = kchan->count_load_time + s->kernel_clock_offset;
137 }
138
139 sc = &pit->channels[0];
140 sc->next_transition_time =
141 pit_get_next_transition_time(sc, sc->count_load_time);
142}
143
144static void kvm_pit_put(PITCommonState *pit)
145{
146 KVMPITState *s = KVM_PIT(pit);
147 struct kvm_pit_state2 kpit = {};
148 struct kvm_pit_channel_state *kchan;
149 struct PITChannelState *sc;
150 int i, ret;
151
152
153 if (s->vm_stopped) {
154 kvm_pit_update_clock_offset(s);
155 }
156
157 kpit.flags = pit->channels[0].irq_disabled ? KVM_PIT_FLAGS_HPET_LEGACY : 0;
158 for (i = 0; i < 3; i++) {
159 kchan = &kpit.channels[i];
160 sc = &pit->channels[i];
161 kchan->count = sc->count;
162 kchan->latched_count = sc->latched_count;
163 kchan->count_latched = sc->count_latched;
164 kchan->status_latched = sc->status_latched;
165 kchan->status = sc->status;
166 kchan->read_state = sc->read_state;
167 kchan->write_state = sc->write_state;
168 kchan->write_latch = sc->write_latch;
169 kchan->rw_mode = sc->rw_mode;
170 kchan->mode = sc->mode;
171 kchan->bcd = sc->bcd;
172 kchan->gate = sc->gate;
173 kchan->count_load_time = sc->count_load_time - s->kernel_clock_offset;
174 }
175
176 ret = kvm_vm_ioctl(kvm_state,
177 kvm_has_pit_state2() ? KVM_SET_PIT2 : KVM_SET_PIT,
178 &kpit);
179 if (ret < 0) {
180 fprintf(stderr, "%s failed: %s\n",
181 kvm_has_pit_state2() ? "KVM_SET_PIT2" : "KVM_SET_PIT",
182 strerror(ret));
183 abort();
184 }
185}
186
187static void kvm_pit_set_gate(PITCommonState *s, PITChannelState *sc, int val)
188{
189 kvm_pit_get(s);
190
191 switch (sc->mode) {
192 default:
193 case 0:
194 case 4:
195
196 break;
197 case 1:
198 case 2:
199 case 3:
200 case 5:
201 if (sc->gate < val) {
202
203 sc->count_load_time = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
204 }
205 break;
206 }
207 sc->gate = val;
208
209 kvm_pit_put(s);
210}
211
212static void kvm_pit_get_channel_info(PITCommonState *s, PITChannelState *sc,
213 PITChannelInfo *info)
214{
215 kvm_pit_get(s);
216
217 pit_get_channel_info_common(s, sc, info);
218}
219
220static void kvm_pit_reset(DeviceState *dev)
221{
222 PITCommonState *s = PIT_COMMON(dev);
223
224 pit_reset_common(s);
225
226 kvm_pit_put(s);
227}
228
229static void kvm_pit_irq_control(void *opaque, int n, int enable)
230{
231 PITCommonState *pit = opaque;
232 PITChannelState *s = &pit->channels[0];
233
234 kvm_pit_get(pit);
235
236 s->irq_disabled = !enable;
237
238 kvm_pit_put(pit);
239}
240
241static void kvm_pit_vm_state_change(void *opaque, int running,
242 RunState state)
243{
244 KVMPITState *s = opaque;
245
246 if (running) {
247 kvm_pit_update_clock_offset(s);
248 kvm_pit_put(PIT_COMMON(s));
249 s->vm_stopped = false;
250 } else {
251 kvm_pit_update_clock_offset(s);
252 kvm_pit_get(PIT_COMMON(s));
253 s->vm_stopped = true;
254 }
255}
256
257static void kvm_pit_realizefn(DeviceState *dev, Error **errp)
258{
259 PITCommonState *pit = PIT_COMMON(dev);
260 KVMPITClass *kpc = KVM_PIT_GET_CLASS(dev);
261 KVMPITState *s = KVM_PIT(pit);
262 struct kvm_pit_config config = {
263 .flags = 0,
264 };
265 int ret;
266
267 if (kvm_check_extension(kvm_state, KVM_CAP_PIT2)) {
268 ret = kvm_vm_ioctl(kvm_state, KVM_CREATE_PIT2, &config);
269 } else {
270 ret = kvm_vm_ioctl(kvm_state, KVM_CREATE_PIT);
271 }
272 if (ret < 0) {
273 error_setg(errp, "Create kernel PIC irqchip failed: %s",
274 strerror(ret));
275 return;
276 }
277 switch (s->lost_tick_policy) {
278 case LOST_TICK_POLICY_DELAY:
279 break;
280 case LOST_TICK_POLICY_DISCARD:
281 if (kvm_check_extension(kvm_state, KVM_CAP_REINJECT_CONTROL)) {
282 struct kvm_reinject_control control = { .pit_reinject = 0 };
283
284 ret = kvm_vm_ioctl(kvm_state, KVM_REINJECT_CONTROL, &control);
285 if (ret < 0) {
286 error_setg(errp,
287 "Can't disable in-kernel PIT reinjection: %s",
288 strerror(ret));
289 return;
290 }
291 }
292 break;
293 default:
294 error_setg(errp, "Lost tick policy not supported.");
295 return;
296 }
297
298 memory_region_init_io(&pit->ioports, OBJECT(dev), NULL, NULL, "kvm-pit", 4);
299
300 qdev_init_gpio_in(dev, kvm_pit_irq_control, 1);
301
302 qemu_add_vm_change_state_handler(kvm_pit_vm_state_change, s);
303
304 kpc->parent_realize(dev, errp);
305}
306
307static Property kvm_pit_properties[] = {
308 DEFINE_PROP_UINT32("iobase", PITCommonState, iobase, -1),
309 DEFINE_PROP_LOSTTICKPOLICY("lost_tick_policy", KVMPITState,
310 lost_tick_policy, LOST_TICK_POLICY_DELAY),
311 DEFINE_PROP_END_OF_LIST(),
312};
313
314static void kvm_pit_class_init(ObjectClass *klass, void *data)
315{
316 KVMPITClass *kpc = KVM_PIT_CLASS(klass);
317 PITCommonClass *k = PIT_COMMON_CLASS(klass);
318 DeviceClass *dc = DEVICE_CLASS(klass);
319
320 device_class_set_parent_realize(dc, kvm_pit_realizefn,
321 &kpc->parent_realize);
322 k->set_channel_gate = kvm_pit_set_gate;
323 k->get_channel_info = kvm_pit_get_channel_info;
324 dc->reset = kvm_pit_reset;
325 dc->props = kvm_pit_properties;
326}
327
328static const TypeInfo kvm_pit_info = {
329 .name = TYPE_KVM_I8254,
330 .parent = TYPE_PIT_COMMON,
331 .instance_size = sizeof(KVMPITState),
332 .class_init = kvm_pit_class_init,
333 .class_size = sizeof(KVMPITClass),
334};
335
336static void kvm_pit_register(void)
337{
338 type_register_static(&kvm_pit_info);
339}
340
341type_init(kvm_pit_register)
342
