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 #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 41 typedef 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 49 typedef struct KVMPITClass { 50 PITCommonClass parent_class; 51 52 DeviceRealize parent_realize; 53 } KVMPITClass; 54 55 static int64_t abs64(int64_t v) 56 { 57 return v < 0 ? -v : v; 58 } 59 60 static 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 * Measure the delta between CLOCK_MONOTONIC, the base used for 68 * kvm_pit_channel_state::count_load_time, and QEMU_CLOCK_VIRTUAL. Take the 69 * minimum of several samples to filter out scheduling noise. 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 84 static 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 /* No need to re-read the state if VM is stopped. */ 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 * kvm_pit_state2 is superset of kvm_pit_state struct, 107 * so we can use it for KVM_GET_PIT as well. 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 138 static 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 /* The offset keeps changing as long as the VM is stopped. */ 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 181 static 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 /* XXX: just disable/enable counting */ 190 break; 191 case 1: 192 case 2: 193 case 3: 194 case 5: 195 if (sc->gate < val) { 196 /* restart counting on rising edge */ 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 206 static 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 214 static 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 223 static 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 235 static 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 s->vm_stopped = false; 243 } else { 244 kvm_pit_update_clock_offset(s); 245 kvm_pit_get(PIT_COMMON(s)); 246 s->vm_stopped = true; 247 } 248 } 249 250 static void kvm_pit_realizefn(DeviceState *dev, Error **errp) 251 { 252 PITCommonState *pit = PIT_COMMON(dev); 253 KVMPITClass *kpc = KVM_PIT_GET_CLASS(dev); 254 KVMPITState *s = KVM_PIT(pit); 255 struct kvm_pit_config config = { 256 .flags = 0, 257 }; 258 int ret; 259 260 if (kvm_check_extension(kvm_state, KVM_CAP_PIT2)) { 261 ret = kvm_vm_ioctl(kvm_state, KVM_CREATE_PIT2, &config); 262 } else { 263 ret = kvm_vm_ioctl(kvm_state, KVM_CREATE_PIT); 264 } 265 if (ret < 0) { 266 error_setg(errp, "Create kernel PIC irqchip failed: %s", 267 strerror(ret)); 268 return; 269 } 270 switch (s->lost_tick_policy) { 271 case LOST_TICK_POLICY_DELAY: 272 break; /* enabled by default */ 273 case LOST_TICK_POLICY_DISCARD: 274 if (kvm_check_extension(kvm_state, KVM_CAP_REINJECT_CONTROL)) { 275 struct kvm_reinject_control control = { .pit_reinject = 0 }; 276 277 ret = kvm_vm_ioctl(kvm_state, KVM_REINJECT_CONTROL, &control); 278 if (ret < 0) { 279 error_setg(errp, 280 "Can't disable in-kernel PIT reinjection: %s", 281 strerror(ret)); 282 return; 283 } 284 } 285 break; 286 default: 287 error_setg(errp, "Lost tick policy not supported."); 288 return; 289 } 290 291 memory_region_init_reservation(&pit->ioports, NULL, "kvm-pit", 4); 292 293 qdev_init_gpio_in(dev, kvm_pit_irq_control, 1); 294 295 qemu_add_vm_change_state_handler(kvm_pit_vm_state_change, s); 296 297 kpc->parent_realize(dev, errp); 298 } 299 300 static Property kvm_pit_properties[] = { 301 DEFINE_PROP_UINT32("iobase", PITCommonState, iobase, -1), 302 DEFINE_PROP_LOSTTICKPOLICY("lost_tick_policy", KVMPITState, 303 lost_tick_policy, LOST_TICK_POLICY_DELAY), 304 DEFINE_PROP_END_OF_LIST(), 305 }; 306 307 static void kvm_pit_class_init(ObjectClass *klass, void *data) 308 { 309 KVMPITClass *kpc = KVM_PIT_CLASS(klass); 310 PITCommonClass *k = PIT_COMMON_CLASS(klass); 311 DeviceClass *dc = DEVICE_CLASS(klass); 312 313 kpc->parent_realize = dc->realize; 314 dc->realize = kvm_pit_realizefn; 315 k->set_channel_gate = kvm_pit_set_gate; 316 k->get_channel_info = kvm_pit_get_channel_info; 317 k->pre_save = kvm_pit_get; 318 k->post_load = kvm_pit_put; 319 dc->reset = kvm_pit_reset; 320 dc->props = kvm_pit_properties; 321 } 322 323 static const TypeInfo kvm_pit_info = { 324 .name = TYPE_KVM_I8254, 325 .parent = TYPE_PIT_COMMON, 326 .instance_size = sizeof(KVMPITState), 327 .class_init = kvm_pit_class_init, 328 .class_size = sizeof(KVMPITClass), 329 }; 330 331 static void kvm_pit_register(void) 332 { 333 type_register_static(&kvm_pit_info); 334 } 335 336 type_init(kvm_pit_register) 337