1 /* 2 * QEMU KVM support, paravirtual clock device 3 * 4 * Copyright (C) 2011 Siemens AG 5 * 6 * Authors: 7 * Jan Kiszka <jan.kiszka@siemens.com> 8 * 9 * This work is licensed under the terms of the GNU GPL version 2. 10 * See the COPYING file in the top-level directory. 11 * 12 * Contributions after 2012-01-13 are licensed under the terms of the 13 * GNU GPL, version 2 or (at your option) any later version. 14 */ 15 16 #include "qemu/osdep.h" 17 #include "qemu-common.h" 18 #include "qemu/host-utils.h" 19 #include "sysemu/sysemu.h" 20 #include "sysemu/kvm.h" 21 #include "kvm_i386.h" 22 #include "hw/sysbus.h" 23 #include "hw/kvm/clock.h" 24 25 #include <linux/kvm.h> 26 #include <linux/kvm_para.h> 27 28 #define TYPE_KVM_CLOCK "kvmclock" 29 #define KVM_CLOCK(obj) OBJECT_CHECK(KVMClockState, (obj), TYPE_KVM_CLOCK) 30 31 typedef struct KVMClockState { 32 /*< private >*/ 33 SysBusDevice busdev; 34 /*< public >*/ 35 36 uint64_t clock; 37 bool clock_valid; 38 } KVMClockState; 39 40 struct pvclock_vcpu_time_info { 41 uint32_t version; 42 uint32_t pad0; 43 uint64_t tsc_timestamp; 44 uint64_t system_time; 45 uint32_t tsc_to_system_mul; 46 int8_t tsc_shift; 47 uint8_t flags; 48 uint8_t pad[2]; 49 } __attribute__((__packed__)); /* 32 bytes */ 50 51 static uint64_t kvmclock_current_nsec(KVMClockState *s) 52 { 53 CPUState *cpu = first_cpu; 54 CPUX86State *env = cpu->env_ptr; 55 hwaddr kvmclock_struct_pa = env->system_time_msr & ~1ULL; 56 uint64_t migration_tsc = env->tsc; 57 struct pvclock_vcpu_time_info time; 58 uint64_t delta; 59 uint64_t nsec_lo; 60 uint64_t nsec_hi; 61 uint64_t nsec; 62 63 if (!(env->system_time_msr & 1ULL)) { 64 /* KVM clock not active */ 65 return 0; 66 } 67 68 cpu_physical_memory_read(kvmclock_struct_pa, &time, sizeof(time)); 69 70 assert(time.tsc_timestamp <= migration_tsc); 71 delta = migration_tsc - time.tsc_timestamp; 72 if (time.tsc_shift < 0) { 73 delta >>= -time.tsc_shift; 74 } else { 75 delta <<= time.tsc_shift; 76 } 77 78 mulu64(&nsec_lo, &nsec_hi, delta, time.tsc_to_system_mul); 79 nsec = (nsec_lo >> 32) | (nsec_hi << 32); 80 return nsec + time.system_time; 81 } 82 83 static void kvmclock_vm_state_change(void *opaque, int running, 84 RunState state) 85 { 86 KVMClockState *s = opaque; 87 CPUState *cpu; 88 int cap_clock_ctrl = kvm_check_extension(kvm_state, KVM_CAP_KVMCLOCK_CTRL); 89 int ret; 90 91 if (running) { 92 struct kvm_clock_data data = {}; 93 uint64_t time_at_migration = kvmclock_current_nsec(s); 94 95 s->clock_valid = false; 96 97 /* We can't rely on the migrated clock value, just discard it */ 98 if (time_at_migration) { 99 s->clock = time_at_migration; 100 } 101 102 data.clock = s->clock; 103 ret = kvm_vm_ioctl(kvm_state, KVM_SET_CLOCK, &data); 104 if (ret < 0) { 105 fprintf(stderr, "KVM_SET_CLOCK failed: %s\n", strerror(ret)); 106 abort(); 107 } 108 109 if (!cap_clock_ctrl) { 110 return; 111 } 112 CPU_FOREACH(cpu) { 113 ret = kvm_vcpu_ioctl(cpu, KVM_KVMCLOCK_CTRL, 0); 114 if (ret) { 115 if (ret != -EINVAL) { 116 fprintf(stderr, "%s: %s\n", __func__, strerror(-ret)); 117 } 118 return; 119 } 120 } 121 } else { 122 struct kvm_clock_data data; 123 int ret; 124 125 if (s->clock_valid) { 126 return; 127 } 128 129 kvm_synchronize_all_tsc(); 130 131 ret = kvm_vm_ioctl(kvm_state, KVM_GET_CLOCK, &data); 132 if (ret < 0) { 133 fprintf(stderr, "KVM_GET_CLOCK failed: %s\n", strerror(ret)); 134 abort(); 135 } 136 s->clock = data.clock; 137 138 /* 139 * If the VM is stopped, declare the clock state valid to 140 * avoid re-reading it on next vmsave (which would return 141 * a different value). Will be reset when the VM is continued. 142 */ 143 s->clock_valid = true; 144 } 145 } 146 147 static void kvmclock_realize(DeviceState *dev, Error **errp) 148 { 149 KVMClockState *s = KVM_CLOCK(dev); 150 151 qemu_add_vm_change_state_handler(kvmclock_vm_state_change, s); 152 } 153 154 static const VMStateDescription kvmclock_vmsd = { 155 .name = "kvmclock", 156 .version_id = 1, 157 .minimum_version_id = 1, 158 .fields = (VMStateField[]) { 159 VMSTATE_UINT64(clock, KVMClockState), 160 VMSTATE_END_OF_LIST() 161 } 162 }; 163 164 static void kvmclock_class_init(ObjectClass *klass, void *data) 165 { 166 DeviceClass *dc = DEVICE_CLASS(klass); 167 168 dc->realize = kvmclock_realize; 169 dc->vmsd = &kvmclock_vmsd; 170 } 171 172 static const TypeInfo kvmclock_info = { 173 .name = TYPE_KVM_CLOCK, 174 .parent = TYPE_SYS_BUS_DEVICE, 175 .instance_size = sizeof(KVMClockState), 176 .class_init = kvmclock_class_init, 177 }; 178 179 /* Note: Must be called after VCPU initialization. */ 180 void kvmclock_create(void) 181 { 182 X86CPU *cpu = X86_CPU(first_cpu); 183 184 if (kvm_enabled() && 185 cpu->env.features[FEAT_KVM] & ((1ULL << KVM_FEATURE_CLOCKSOURCE) | 186 (1ULL << KVM_FEATURE_CLOCKSOURCE2))) { 187 sysbus_create_simple(TYPE_KVM_CLOCK, -1, NULL); 188 } 189 } 190 191 static void kvmclock_register_types(void) 192 { 193 type_register_static(&kvmclock_info); 194 } 195 196 type_init(kvmclock_register_types) 197