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-common.h" 17 #include "qemu/host-utils.h" 18 #include "sysemu/sysemu.h" 19 #include "sysemu/kvm.h" 20 #include "sysemu/cpus.h" 21 #include "hw/sysbus.h" 22 #include "hw/kvm/clock.h" 23 24 #include <linux/kvm.h> 25 #include <linux/kvm_para.h> 26 27 #define TYPE_KVM_CLOCK "kvmclock" 28 #define KVM_CLOCK(obj) OBJECT_CHECK(KVMClockState, (obj), TYPE_KVM_CLOCK) 29 30 typedef struct KVMClockState { 31 /*< private >*/ 32 SysBusDevice busdev; 33 /*< public >*/ 34 35 uint64_t clock; 36 bool clock_valid; 37 } KVMClockState; 38 39 struct pvclock_vcpu_time_info { 40 uint32_t version; 41 uint32_t pad0; 42 uint64_t tsc_timestamp; 43 uint64_t system_time; 44 uint32_t tsc_to_system_mul; 45 int8_t tsc_shift; 46 uint8_t flags; 47 uint8_t pad[2]; 48 } __attribute__((__packed__)); /* 32 bytes */ 49 50 static uint64_t kvmclock_current_nsec(KVMClockState *s) 51 { 52 CPUState *cpu = first_cpu; 53 CPUX86State *env = cpu->env_ptr; 54 hwaddr kvmclock_struct_pa = env->system_time_msr & ~1ULL; 55 uint64_t migration_tsc = env->tsc; 56 struct pvclock_vcpu_time_info time; 57 uint64_t delta; 58 uint64_t nsec_lo; 59 uint64_t nsec_hi; 60 uint64_t nsec; 61 62 if (!(env->system_time_msr & 1ULL)) { 63 /* KVM clock not active */ 64 return 0; 65 } 66 67 cpu_physical_memory_read(kvmclock_struct_pa, &time, sizeof(time)); 68 69 assert(time.tsc_timestamp <= migration_tsc); 70 delta = migration_tsc - time.tsc_timestamp; 71 if (time.tsc_shift < 0) { 72 delta >>= -time.tsc_shift; 73 } else { 74 delta <<= time.tsc_shift; 75 } 76 77 mulu64(&nsec_lo, &nsec_hi, delta, time.tsc_to_system_mul); 78 nsec = (nsec_lo >> 32) | (nsec_hi << 32); 79 return nsec + time.system_time; 80 } 81 82 static void kvmclock_vm_state_change(void *opaque, int running, 83 RunState state) 84 { 85 KVMClockState *s = opaque; 86 CPUState *cpu; 87 int cap_clock_ctrl = kvm_check_extension(kvm_state, KVM_CAP_KVMCLOCK_CTRL); 88 int ret; 89 90 if (running) { 91 struct kvm_clock_data data; 92 uint64_t time_at_migration = kvmclock_current_nsec(s); 93 94 s->clock_valid = false; 95 96 /* We can't rely on the migrated clock value, just discard it */ 97 if (time_at_migration) { 98 s->clock = time_at_migration; 99 } 100 101 data.clock = s->clock; 102 data.flags = 0; 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 cpu_synchronize_all_states(); 130 ret = kvm_vm_ioctl(kvm_state, KVM_GET_CLOCK, &data); 131 if (ret < 0) { 132 fprintf(stderr, "KVM_GET_CLOCK failed: %s\n", strerror(ret)); 133 abort(); 134 } 135 s->clock = data.clock; 136 137 /* 138 * If the VM is stopped, declare the clock state valid to 139 * avoid re-reading it on next vmsave (which would return 140 * a different value). Will be reset when the VM is continued. 141 */ 142 s->clock_valid = true; 143 } 144 } 145 146 static void kvmclock_realize(DeviceState *dev, Error **errp) 147 { 148 KVMClockState *s = KVM_CLOCK(dev); 149 150 qemu_add_vm_change_state_handler(kvmclock_vm_state_change, s); 151 } 152 153 static const VMStateDescription kvmclock_vmsd = { 154 .name = "kvmclock", 155 .version_id = 1, 156 .minimum_version_id = 1, 157 .fields = (VMStateField[]) { 158 VMSTATE_UINT64(clock, KVMClockState), 159 VMSTATE_END_OF_LIST() 160 } 161 }; 162 163 static void kvmclock_class_init(ObjectClass *klass, void *data) 164 { 165 DeviceClass *dc = DEVICE_CLASS(klass); 166 167 dc->realize = kvmclock_realize; 168 dc->vmsd = &kvmclock_vmsd; 169 } 170 171 static const TypeInfo kvmclock_info = { 172 .name = TYPE_KVM_CLOCK, 173 .parent = TYPE_SYS_BUS_DEVICE, 174 .instance_size = sizeof(KVMClockState), 175 .class_init = kvmclock_class_init, 176 }; 177 178 /* Note: Must be called after VCPU initialization. */ 179 void kvmclock_create(void) 180 { 181 X86CPU *cpu = X86_CPU(first_cpu); 182 183 if (kvm_enabled() && 184 cpu->env.features[FEAT_KVM] & ((1ULL << KVM_FEATURE_CLOCKSOURCE) | 185 (1ULL << KVM_FEATURE_CLOCKSOURCE2))) { 186 sysbus_create_simple(TYPE_KVM_CLOCK, -1, NULL); 187 } 188 } 189 190 static void kvmclock_register_types(void) 191 { 192 type_register_static(&kvmclock_info); 193 } 194 195 type_init(kvmclock_register_types) 196