Return to clock.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / hw / kvm

Annotation of qemu/hw/kvm/clock.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * QEMU KVM support, paravirtual clock device
                      3:  *
                      4:  * Copyright (C) 2011 Siemens AG
                      5:  *
                      6:  * Authors:
                      7:  *  Jan Kiszka        <[email protected]>
                      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 "sysemu.h"
                     18: #include "kvm.h"
                     19: #include "hw/sysbus.h"
                     20: #include "hw/kvm/clock.h"
                     21: 
                     22: #include <linux/kvm.h>
                     23: #include <linux/kvm_para.h>
                     24: 
                     25: typedef struct KVMClockState {
                     26:     SysBusDevice busdev;
                     27:     uint64_t clock;
                     28:     bool clock_valid;
                     29: } KVMClockState;
                     30: 
                     31: static void kvmclock_pre_save(void *opaque)
                     32: {
                     33:     KVMClockState *s = opaque;
                     34:     struct kvm_clock_data data;
                     35:     int ret;
                     36: 
                     37:     if (s->clock_valid) {
                     38:         return;
                     39:     }
                     40:     ret = kvm_vm_ioctl(kvm_state, KVM_GET_CLOCK, &data);
                     41:     if (ret < 0) {
                     42:         fprintf(stderr, "KVM_GET_CLOCK failed: %s\n", strerror(ret));
                     43:         data.clock = 0;
                     44:     }
                     45:     s->clock = data.clock;
                     46:     /*
                     47:      * If the VM is stopped, declare the clock state valid to avoid re-reading
                     48:      * it on next vmsave (which would return a different value). Will be reset
                     49:      * when the VM is continued.
                     50:      */
                     51:     s->clock_valid = !runstate_is_running();
                     52: }
                     53: 
                     54: static int kvmclock_post_load(void *opaque, int version_id)
                     55: {
                     56:     KVMClockState *s = opaque;
                     57:     struct kvm_clock_data data;
                     58: 
                     59:     data.clock = s->clock;
                     60:     data.flags = 0;
                     61:     return kvm_vm_ioctl(kvm_state, KVM_SET_CLOCK, &data);
                     62: }
                     63: 
                     64: static void kvmclock_vm_state_change(void *opaque, int running,
                     65:                                      RunState state)
                     66: {
                     67:     KVMClockState *s = opaque;
                     68:     CPUArchState *penv = first_cpu;
                     69:     int cap_clock_ctrl = kvm_check_extension(kvm_state, KVM_CAP_KVMCLOCK_CTRL);
                     70:     int ret;
                     71: 
                     72:     if (running) {
                     73:         s->clock_valid = false;
                     74: 
                     75:         if (!cap_clock_ctrl) {
                     76:             return;
                     77:         }
                     78:         for (penv = first_cpu; penv != NULL; penv = penv->next_cpu) {
                     79:             ret = kvm_vcpu_ioctl(penv, KVM_KVMCLOCK_CTRL, 0);
                     80:             if (ret) {
                     81:                 if (ret != -EINVAL) {
                     82:                     fprintf(stderr, "%s: %s\n", __func__, strerror(-ret));
                     83:                 }
                     84:                 return;
                     85:             }
                     86:         }
                     87:     }
                     88: }
                     89: 
                     90: static int kvmclock_init(SysBusDevice *dev)
                     91: {
                     92:     KVMClockState *s = FROM_SYSBUS(KVMClockState, dev);
                     93: 
                     94:     qemu_add_vm_change_state_handler(kvmclock_vm_state_change, s);
                     95:     return 0;
                     96: }
                     97: 
                     98: static const VMStateDescription kvmclock_vmsd = {
                     99:     .name = "kvmclock",
                    100:     .version_id = 1,
                    101:     .minimum_version_id = 1,
                    102:     .minimum_version_id_old = 1,
                    103:     .pre_save = kvmclock_pre_save,
                    104:     .post_load = kvmclock_post_load,
                    105:     .fields = (VMStateField[]) {
                    106:         VMSTATE_UINT64(clock, KVMClockState),
                    107:         VMSTATE_END_OF_LIST()
                    108:     }
                    109: };
                    110: 
                    111: static void kvmclock_class_init(ObjectClass *klass, void *data)
                    112: {
                    113:     DeviceClass *dc = DEVICE_CLASS(klass);
                    114:     SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass);
                    115: 
                    116:     k->init = kvmclock_init;
                    117:     dc->no_user = 1;
                    118:     dc->vmsd = &kvmclock_vmsd;
                    119: }
                    120: 
                    121: static TypeInfo kvmclock_info = {
                    122:     .name          = "kvmclock",
                    123:     .parent        = TYPE_SYS_BUS_DEVICE,
                    124:     .instance_size = sizeof(KVMClockState),
                    125:     .class_init    = kvmclock_class_init,
                    126: };
                    127: 
                    128: /* Note: Must be called after VCPU initialization. */
                    129: void kvmclock_create(void)
                    130: {
                    131:     if (kvm_enabled() &&
                    132:         first_cpu->cpuid_kvm_features & ((1ULL << KVM_FEATURE_CLOCKSOURCE) |
                    133:                                          (1ULL << KVM_FEATURE_CLOCKSOURCE2))) {
                    134:         sysbus_create_simple("kvmclock", -1, NULL);
                    135:     }
                    136: }
                    137: 
                    138: static void kvmclock_register_types(void)
                    139: {
                    140:     type_register_static(&kvmclock_info);
                    141: }
                    142: 
                    143: type_init(kvmclock_register_types)

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.