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