[mirror_qemu.git] / hw / s390x / s390-stattrib-kvm.c

/*
 * s390 storage attributes device -- KVM object
 *
 * Copyright 2016 IBM Corp.
 * Author(s): Claudio Imbrenda <imbrenda@linux.vnet.ibm.com>
 *
 * This work is licensed under the terms of the GNU GPL, version 2 or (at
 * your option) any later version. See the COPYING file in the top-level
 * directory.
 */

#include "qemu/osdep.h"
#include "hw/boards.h"
#include "migration/qemu-file.h"
#include "hw/s390x/storage-attributes.h"
#include "qemu/error-report.h"
#include "sysemu/kvm.h"
#include "exec/ram_addr.h"
#include "cpu.h"
#include "kvm_s390x.h"

Object *kvm_s390_stattrib_create(void)
{
    if (kvm_enabled() &&
                kvm_check_extension(kvm_state, KVM_CAP_S390_CMMA_MIGRATION)) {
        return object_new(TYPE_KVM_S390_STATTRIB);
    }
    return NULL;
}

static void kvm_s390_stattrib_instance_init(Object *obj)
{
    KVMS390StAttribState *sas = KVM_S390_STATTRIB(obj);

    sas->still_dirty = 0;
}

static int kvm_s390_stattrib_read_helper(S390StAttribState *sa,
                                         uint64_t *start_gfn,
                                         uint32_t count,
                                         uint8_t *values,
                                         uint32_t flags)
{
    KVMS390StAttribState *sas = KVM_S390_STATTRIB(sa);
    int r;
    struct kvm_s390_cmma_log clog = {
        .values = (uint64_t)values,
        .start_gfn = *start_gfn,
        .count = count,
        .flags = flags,
    };

    r = kvm_vm_ioctl(kvm_state, KVM_S390_GET_CMMA_BITS, &clog);
    if (r < 0) {
        error_report("KVM_S390_GET_CMMA_BITS failed: %s", strerror(-r));
        return r;
    }

    *start_gfn = clog.start_gfn;
    sas->still_dirty = clog.remaining;
    return clog.count;
}

static int kvm_s390_stattrib_get_stattr(S390StAttribState *sa,
                                        uint64_t *start_gfn,
                                        uint32_t count,
                                        uint8_t *values)
{
    return kvm_s390_stattrib_read_helper(sa, start_gfn, count, values, 0);
}

static int kvm_s390_stattrib_peek_stattr(S390StAttribState *sa,
                                         uint64_t start_gfn,
                                         uint32_t count,
                                         uint8_t *values)
{
    return kvm_s390_stattrib_read_helper(sa, &start_gfn, count, values,
                                         KVM_S390_CMMA_PEEK);
}

static int kvm_s390_stattrib_set_stattr(S390StAttribState *sa,
                                        uint64_t start_gfn,
                                        uint32_t count,
                                        uint8_t *values)
{
    KVMS390StAttribState *sas = KVM_S390_STATTRIB(sa);
    MachineState *machine = MACHINE(qdev_get_machine());
    unsigned long max = machine->maxram_size / TARGET_PAGE_SIZE;

    if (start_gfn + count > max) {
        error_report("Out of memory bounds when setting storage attributes");
        return -1;
    }
    if (!sas->incoming_buffer) {
        sas->incoming_buffer = g_malloc0(max);
    }

    memcpy(sas->incoming_buffer + start_gfn, values, count);

    return 0;
}

static void kvm_s390_stattrib_synchronize(S390StAttribState *sa)
{
    KVMS390StAttribState *sas = KVM_S390_STATTRIB(sa);
    MachineState *machine = MACHINE(qdev_get_machine());
    unsigned long max = machine->maxram_size / TARGET_PAGE_SIZE;
    unsigned long cx, len = 1 << 19;
    int r;
    struct kvm_s390_cmma_log clog = {
        .flags = 0,
        .mask = ~0ULL,
    };

    if (sas->incoming_buffer) {
        for (cx = 0; cx + len <= max; cx += len) {
            clog.start_gfn = cx;
            clog.count = len;
            clog.values = (uint64_t)(sas->incoming_buffer + cx);
            r = kvm_vm_ioctl(kvm_state, KVM_S390_SET_CMMA_BITS, &clog);
            if (r) {
                error_report("KVM_S390_SET_CMMA_BITS failed: %s", strerror(-r));
                return;
            }
        }
        if (cx < max) {
            clog.start_gfn = cx;
            clog.count = max - cx;
            clog.values = (uint64_t)(sas->incoming_buffer + cx);
            r = kvm_vm_ioctl(kvm_state, KVM_S390_SET_CMMA_BITS, &clog);
            if (r) {
                error_report("KVM_S390_SET_CMMA_BITS failed: %s", strerror(-r));
            }
        }
        g_free(sas->incoming_buffer);
        sas->incoming_buffer = NULL;
    }
}

static int kvm_s390_stattrib_set_migrationmode(S390StAttribState *sa, bool val)
{
    struct kvm_device_attr attr = {
        .group = KVM_S390_VM_MIGRATION,
        .attr = val,
        .addr = 0,
    };
    return kvm_vm_ioctl(kvm_state, KVM_SET_DEVICE_ATTR, &attr);
}

static long long kvm_s390_stattrib_get_dirtycount(S390StAttribState *sa)
{
    KVMS390StAttribState *sas = KVM_S390_STATTRIB(sa);
    uint8_t val[8];

    kvm_s390_stattrib_peek_stattr(sa, 0, 1, val);
    return sas->still_dirty;
}

static int kvm_s390_stattrib_get_active(S390StAttribState *sa)
{
    return kvm_s390_cmma_active() && sa->migration_enabled;
}

static void kvm_s390_stattrib_class_init(ObjectClass *oc, void *data)
{
    S390StAttribClass *sac = S390_STATTRIB_CLASS(oc);
    DeviceClass *dc = DEVICE_CLASS(oc);

    sac->get_stattr = kvm_s390_stattrib_get_stattr;
    sac->peek_stattr = kvm_s390_stattrib_peek_stattr;
    sac->set_stattr = kvm_s390_stattrib_set_stattr;
    sac->set_migrationmode = kvm_s390_stattrib_set_migrationmode;
    sac->get_dirtycount = kvm_s390_stattrib_get_dirtycount;
    sac->synchronize = kvm_s390_stattrib_synchronize;
    sac->get_active = kvm_s390_stattrib_get_active;

    /* Reason: Can only be instantiated one time (internally) */
    dc->user_creatable = false;
}

static const TypeInfo kvm_s390_stattrib_info = {
    .name          = TYPE_KVM_S390_STATTRIB,
    .parent        = TYPE_S390_STATTRIB,
    .instance_init = kvm_s390_stattrib_instance_init,
    .instance_size = sizeof(KVMS390StAttribState),
    .class_init    = kvm_s390_stattrib_class_init,
    .class_size    = sizeof(S390StAttribClass),
};

static void kvm_s390_stattrib_register_types(void)
{
    type_register_static(&kvm_s390_stattrib_info);
}

type_init(kvm_s390_stattrib_register_types)
Commit	Line	Data
903fd80b CI	1	/*
	2	* s390 storage attributes device -- KVM object
	3	*
	4	* Copyright 2016 IBM Corp.
	5	* Author(s): Claudio Imbrenda <imbrenda@linux.vnet.ibm.com>
	6	*
	7	* This work is licensed under the terms of the GNU GPL, version 2 or (at
	8	* your option) any later version. See the COPYING file in the top-level
	9	* directory.
	10	*/
	11
	12	#include "qemu/osdep.h"
	13	#include "hw/boards.h"
	14	#include "migration/qemu-file.h"
	15	#include "hw/s390x/storage-attributes.h"
	16	#include "qemu/error-report.h"
	17	#include "sysemu/kvm.h"
	18	#include "exec/ram_addr.h"
	19	#include "cpu.h"
f16bbb9b	20	#include "kvm_s390x.h"
903fd80b CI	21
	22	Object *kvm_s390_stattrib_create(void)
	23	{
	24	if (kvm_enabled() &&
	25	kvm_check_extension(kvm_state, KVM_CAP_S390_CMMA_MIGRATION)) {
	26	return object_new(TYPE_KVM_S390_STATTRIB);
	27	}
	28	return NULL;
	29	}
	30
	31	static void kvm_s390_stattrib_instance_init(Object *obj)
	32	{
	33	KVMS390StAttribState *sas = KVM_S390_STATTRIB(obj);
	34
	35	sas->still_dirty = 0;
	36	}
	37
	38	static int kvm_s390_stattrib_read_helper(S390StAttribState *sa,
	39	uint64_t *start_gfn,
	40	uint32_t count,
	41	uint8_t *values,
	42	uint32_t flags)
	43	{
	44	KVMS390StAttribState *sas = KVM_S390_STATTRIB(sa);
	45	int r;
	46	struct kvm_s390_cmma_log clog = {
	47	.values = (uint64_t)values,
	48	.start_gfn = *start_gfn,
	49	.count = count,
	50	.flags = flags,
	51	};
	52
	53	r = kvm_vm_ioctl(kvm_state, KVM_S390_GET_CMMA_BITS, &clog);
	54	if (r < 0) {
	55	error_report("KVM_S390_GET_CMMA_BITS failed: %s", strerror(-r));
	56	return r;
	57	}
	58
	59	*start_gfn = clog.start_gfn;
	60	sas->still_dirty = clog.remaining;
	61	return clog.count;
	62	}
	63
	64	static int kvm_s390_stattrib_get_stattr(S390StAttribState *sa,
	65	uint64_t *start_gfn,
	66	uint32_t count,
	67	uint8_t *values)
	68	{
	69	return kvm_s390_stattrib_read_helper(sa, start_gfn, count, values, 0);
	70	}
	71
	72	static int kvm_s390_stattrib_peek_stattr(S390StAttribState *sa,
	73	uint64_t start_gfn,
	74	uint32_t count,
	75	uint8_t *values)
	76	{
	77	return kvm_s390_stattrib_read_helper(sa, &start_gfn, count, values,
	78	KVM_S390_CMMA_PEEK);
	79	}
	80
	81	static int kvm_s390_stattrib_set_stattr(S390StAttribState *sa,
	82	uint64_t start_gfn,
	83	uint32_t count,
	84	uint8_t *values)
85	{
86	KVMS390StAttribState *sas = KVM_S390_STATTRIB(sa);
87	MachineState *machine = MACHINE(qdev_get_machine());
88	unsigned long max = machine->maxram_size / TARGET_PAGE_SIZE;
89
90	if (start_gfn + count > max) {
91	error_report("Out of memory bounds when setting storage attributes");
92	return -1;
93	}
94	if (!sas->incoming_buffer) {
95	sas->incoming_buffer = g_malloc0(max);
96	}
97
98	memcpy(sas->incoming_buffer + start_gfn, values, count);
99
100	return 0;
101	}
102
103	static void kvm_s390_stattrib_synchronize(S390StAttribState *sa)
104	{
105	KVMS390StAttribState *sas = KVM_S390_STATTRIB(sa);
106	MachineState *machine = MACHINE(qdev_get_machine());
107	unsigned long max = machine->maxram_size / TARGET_PAGE_SIZE;
108	unsigned long cx, len = 1 << 19;
109	int r;
110	struct kvm_s390_cmma_log clog = {
111	.flags = 0,
112	.mask = ~0ULL,
113	};
114
115	if (sas->incoming_buffer) {
116	for (cx = 0; cx + len <= max; cx += len) {
117	clog.start_gfn = cx;
118	clog.count = len;
e7857ad9	119	clog.values = (uint64_t)(sas->incoming_buffer + cx);
903fd80b CI	120	r = kvm_vm_ioctl(kvm_state, KVM_S390_SET_CMMA_BITS, &clog);
	121	if (r) {
	122	error_report("KVM_S390_SET_CMMA_BITS failed: %s", strerror(-r));
	123	return;
	124	}
	125	}
	126	if (cx < max) {
	127	clog.start_gfn = cx;
	128	clog.count = max - cx;
e7857ad9	129	clog.values = (uint64_t)(sas->incoming_buffer + cx);
903fd80b CI	130	r = kvm_vm_ioctl(kvm_state, KVM_S390_SET_CMMA_BITS, &clog);
	131	if (r) {
	132	error_report("KVM_S390_SET_CMMA_BITS failed: %s", strerror(-r));
	133	}
	134	}
	135	g_free(sas->incoming_buffer);
	136	sas->incoming_buffer = NULL;
	137	}
	138	}
	139
	140	static int kvm_s390_stattrib_set_migrationmode(S390StAttribState *sa, bool val)
	141	{
	142	struct kvm_device_attr attr = {
	143	.group = KVM_S390_VM_MIGRATION,
	144	.attr = val,
	145	.addr = 0,
	146	};
	147	return kvm_vm_ioctl(kvm_state, KVM_SET_DEVICE_ATTR, &attr);
	148	}
	149
	150	static long long kvm_s390_stattrib_get_dirtycount(S390StAttribState *sa)
	151	{
	152	KVMS390StAttribState *sas = KVM_S390_STATTRIB(sa);
	153	uint8_t val[8];
	154
	155	kvm_s390_stattrib_peek_stattr(sa, 0, 1, val);
	156	return sas->still_dirty;
	157	}
	158
	159	static int kvm_s390_stattrib_get_active(S390StAttribState *sa)
	160	{
	161	return kvm_s390_cmma_active() && sa->migration_enabled;
	162	}
	163
	164	static void kvm_s390_stattrib_class_init(ObjectClass oc, void data)
	165	{
	166	S390StAttribClass *sac = S390_STATTRIB_CLASS(oc);
3ea6d20e	167	DeviceClass *dc = DEVICE_CLASS(oc);
903fd80b CI	168
	169	sac->get_stattr = kvm_s390_stattrib_get_stattr;
	170	sac->peek_stattr = kvm_s390_stattrib_peek_stattr;
	171	sac->set_stattr = kvm_s390_stattrib_set_stattr;
	172	sac->set_migrationmode = kvm_s390_stattrib_set_migrationmode;
	173	sac->get_dirtycount = kvm_s390_stattrib_get_dirtycount;
	174	sac->synchronize = kvm_s390_stattrib_synchronize;
	175	sac->get_active = kvm_s390_stattrib_get_active;
3ea6d20e TH	176
	177	/* Reason: Can only be instantiated one time (internally) */
	178	dc->user_creatable = false;
903fd80b CI	179	}
	180
	181	static const TypeInfo kvm_s390_stattrib_info = {
	182	.name = TYPE_KVM_S390_STATTRIB,
	183	.parent = TYPE_S390_STATTRIB,
	184	.instance_init = kvm_s390_stattrib_instance_init,
	185	.instance_size = sizeof(KVMS390StAttribState),
	186	.class_init = kvm_s390_stattrib_class_init,
	187	.class_size = sizeof(S390StAttribClass),
	188	};
	189
	190	static void kvm_s390_stattrib_register_types(void)
	191	{
	192	type_register_static(&kvm_s390_stattrib_info);
	193	}
	194
	195	type_init(kvm_s390_stattrib_register_types)