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