mirror of
https://github.com/qemu/qemu.git
synced 2025-07-29 06:26:06 +00:00
efec3dd631
In an ideal world, machines can be built by wiring devices together
with configuration, not code. Unfortunately, that's not the world we
live in right now. We still have quite a few devices that need to be
wired up by code. If you try to device_add such a device, it'll fail
in sometimes mysterious ways. If you're lucky, you get an
unmysterious immediate crash.
To protect users from such badness, DeviceClass member no_user used to
make device models unavailable with -device / device_add, but that
regressed in commit 18b6dad. The device model is still omitted from
help, but is available anyway.
Attempts to fix the regression have been rejected with the argument
that the purpose of no_user isn't clear, and it's prone to misuse.
This commit clarifies no_user's purpose. Anthony suggested to rename
it cannot_instantiate_with_device_add_yet_due_to_internal_bugs, which
I shorten somewhat to keep checkpatch happy. While there, make it
bool.
Every use of cannot_instantiate_with_device_add_yet gets a FIXME
comment asking for rationale. The next few commits will clean them
all up, either by providing a rationale, or by getting rid of the use.
With that done, the regression fix is hopefully acceptable.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Marcel Apfelbaum <marcel.a@redhat.com>
Signed-off-by: Andreas Färber <afaerber@suse.de>
146 lines
3.7 KiB
C
146 lines
3.7 KiB
C
/*
|
|
* QEMU KVM support, paravirtual clock device
|
|
*
|
|
* Copyright (C) 2011 Siemens AG
|
|
*
|
|
* Authors:
|
|
* Jan Kiszka <jan.kiszka@siemens.com>
|
|
*
|
|
* This work is licensed under the terms of the GNU GPL version 2.
|
|
* See the COPYING file in the top-level directory.
|
|
*
|
|
* Contributions after 2012-01-13 are licensed under the terms of the
|
|
* GNU GPL, version 2 or (at your option) any later version.
|
|
*/
|
|
|
|
#include "qemu-common.h"
|
|
#include "sysemu/sysemu.h"
|
|
#include "sysemu/kvm.h"
|
|
#include "hw/sysbus.h"
|
|
#include "hw/kvm/clock.h"
|
|
|
|
#include <linux/kvm.h>
|
|
#include <linux/kvm_para.h>
|
|
|
|
#define TYPE_KVM_CLOCK "kvmclock"
|
|
#define KVM_CLOCK(obj) OBJECT_CHECK(KVMClockState, (obj), TYPE_KVM_CLOCK)
|
|
|
|
typedef struct KVMClockState {
|
|
/*< private >*/
|
|
SysBusDevice busdev;
|
|
/*< public >*/
|
|
|
|
uint64_t clock;
|
|
bool clock_valid;
|
|
} KVMClockState;
|
|
|
|
|
|
static void kvmclock_vm_state_change(void *opaque, int running,
|
|
RunState state)
|
|
{
|
|
KVMClockState *s = opaque;
|
|
CPUState *cpu;
|
|
int cap_clock_ctrl = kvm_check_extension(kvm_state, KVM_CAP_KVMCLOCK_CTRL);
|
|
int ret;
|
|
|
|
if (running) {
|
|
struct kvm_clock_data data;
|
|
|
|
s->clock_valid = false;
|
|
|
|
data.clock = s->clock;
|
|
data.flags = 0;
|
|
ret = kvm_vm_ioctl(kvm_state, KVM_SET_CLOCK, &data);
|
|
if (ret < 0) {
|
|
fprintf(stderr, "KVM_SET_CLOCK failed: %s\n", strerror(ret));
|
|
abort();
|
|
}
|
|
|
|
if (!cap_clock_ctrl) {
|
|
return;
|
|
}
|
|
CPU_FOREACH(cpu) {
|
|
ret = kvm_vcpu_ioctl(cpu, KVM_KVMCLOCK_CTRL, 0);
|
|
if (ret) {
|
|
if (ret != -EINVAL) {
|
|
fprintf(stderr, "%s: %s\n", __func__, strerror(-ret));
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
} else {
|
|
struct kvm_clock_data data;
|
|
int ret;
|
|
|
|
if (s->clock_valid) {
|
|
return;
|
|
}
|
|
ret = kvm_vm_ioctl(kvm_state, KVM_GET_CLOCK, &data);
|
|
if (ret < 0) {
|
|
fprintf(stderr, "KVM_GET_CLOCK failed: %s\n", strerror(ret));
|
|
abort();
|
|
}
|
|
s->clock = data.clock;
|
|
|
|
/*
|
|
* If the VM is stopped, declare the clock state valid to
|
|
* avoid re-reading it on next vmsave (which would return
|
|
* a different value). Will be reset when the VM is continued.
|
|
*/
|
|
s->clock_valid = true;
|
|
}
|
|
}
|
|
|
|
static void kvmclock_realize(DeviceState *dev, Error **errp)
|
|
{
|
|
KVMClockState *s = KVM_CLOCK(dev);
|
|
|
|
qemu_add_vm_change_state_handler(kvmclock_vm_state_change, s);
|
|
}
|
|
|
|
static const VMStateDescription kvmclock_vmsd = {
|
|
.name = "kvmclock",
|
|
.version_id = 1,
|
|
.minimum_version_id = 1,
|
|
.minimum_version_id_old = 1,
|
|
.fields = (VMStateField[]) {
|
|
VMSTATE_UINT64(clock, KVMClockState),
|
|
VMSTATE_END_OF_LIST()
|
|
}
|
|
};
|
|
|
|
static void kvmclock_class_init(ObjectClass *klass, void *data)
|
|
{
|
|
DeviceClass *dc = DEVICE_CLASS(klass);
|
|
|
|
dc->realize = kvmclock_realize;
|
|
dc->cannot_instantiate_with_device_add_yet = true; /* FIXME explain why */
|
|
dc->vmsd = &kvmclock_vmsd;
|
|
}
|
|
|
|
static const TypeInfo kvmclock_info = {
|
|
.name = TYPE_KVM_CLOCK,
|
|
.parent = TYPE_SYS_BUS_DEVICE,
|
|
.instance_size = sizeof(KVMClockState),
|
|
.class_init = kvmclock_class_init,
|
|
};
|
|
|
|
/* Note: Must be called after VCPU initialization. */
|
|
void kvmclock_create(void)
|
|
{
|
|
X86CPU *cpu = X86_CPU(first_cpu);
|
|
|
|
if (kvm_enabled() &&
|
|
cpu->env.features[FEAT_KVM] & ((1ULL << KVM_FEATURE_CLOCKSOURCE) |
|
|
(1ULL << KVM_FEATURE_CLOCKSOURCE2))) {
|
|
sysbus_create_simple(TYPE_KVM_CLOCK, -1, NULL);
|
|
}
|
|
}
|
|
|
|
static void kvmclock_register_types(void)
|
|
{
|
|
type_register_static(&kvmclock_info);
|
|
}
|
|
|
|
type_init(kvmclock_register_types)
|