[qemu.git] / hw / virtio / virtio-balloon.c

/*
 * Virtio Balloon Device
 *
 * Copyright IBM, Corp. 2008
 * Copyright (C) 2011 Red Hat, Inc.
 * Copyright (C) 2011 Amit Shah <amit.shah@redhat.com>
 *
 * Authors:
 *  Anthony Liguori   <aliguori@us.ibm.com>
 *
 * This work is licensed under the terms of the GNU GPL, version 2.  See
 * the COPYING file in the top-level directory.
 *
 */

#include "qemu/iov.h"
#include "qemu/timer.h"
#include "qemu-common.h"
#include "hw/virtio/virtio.h"
#include "hw/i386/pc.h"
#include "cpu.h"
#include "sysemu/balloon.h"
#include "hw/virtio/virtio-balloon.h"
#include "sysemu/kvm.h"
#include "exec/address-spaces.h"
#include "qapi/visitor.h"

#if defined(__linux__)
#include <sys/mman.h>
#endif

#include "hw/virtio/virtio-bus.h"

static void balloon_page(void *addr, int deflate)
{
#if defined(__linux__)
    if (!kvm_enabled() || kvm_has_sync_mmu())
        qemu_madvise(addr, TARGET_PAGE_SIZE,
                deflate ? QEMU_MADV_WILLNEED : QEMU_MADV_DONTNEED);
#endif
}

static const char *balloon_stat_names[] = {
   [VIRTIO_BALLOON_S_SWAP_IN] = "stat-swap-in",
   [VIRTIO_BALLOON_S_SWAP_OUT] = "stat-swap-out",
   [VIRTIO_BALLOON_S_MAJFLT] = "stat-major-faults",
   [VIRTIO_BALLOON_S_MINFLT] = "stat-minor-faults",
   [VIRTIO_BALLOON_S_MEMFREE] = "stat-free-memory",
   [VIRTIO_BALLOON_S_MEMTOT] = "stat-total-memory",
   [VIRTIO_BALLOON_S_NR] = NULL
};

/*
 * reset_stats - Mark all items in the stats array as unset
 *
 * This function needs to be called at device intialization and before
 * before updating to a set of newly-generated stats.  This will ensure that no
 * stale values stick around in case the guest reports a subset of the supported
 * statistics.
 */
static inline void reset_stats(VirtIOBalloon *dev)
{
    int i;
    for (i = 0; i < VIRTIO_BALLOON_S_NR; dev->stats[i++] = -1);
}

static bool balloon_stats_supported(const VirtIOBalloon *s)
{
    VirtIODevice *vdev = VIRTIO_DEVICE(s);
    return vdev->guest_features & (1 << VIRTIO_BALLOON_F_STATS_VQ);
}

static bool balloon_stats_enabled(const VirtIOBalloon *s)
{
    return s->stats_poll_interval > 0;
}

static void balloon_stats_destroy_timer(VirtIOBalloon *s)
{
    if (balloon_stats_enabled(s)) {
        qemu_del_timer(s->stats_timer);
        qemu_free_timer(s->stats_timer);
        s->stats_timer = NULL;
        s->stats_poll_interval = 0;
    }
}

static void balloon_stats_change_timer(VirtIOBalloon *s, int secs)
{
    qemu_mod_timer(s->stats_timer, qemu_get_clock_ms(vm_clock) + secs * 1000);
}

static void balloon_stats_poll_cb(void *opaque)
{
    VirtIOBalloon *s = opaque;
    VirtIODevice *vdev = VIRTIO_DEVICE(s);

    if (!balloon_stats_supported(s)) {
        /* re-schedule */
        balloon_stats_change_timer(s, s->stats_poll_interval);
        return;
    }

    virtqueue_push(s->svq, &s->stats_vq_elem, s->stats_vq_offset);
    virtio_notify(vdev, s->svq);
}

static void balloon_stats_get_all(Object *obj, struct Visitor *v,
                                  void *opaque, const char *name, Error **errp)
{
    VirtIOBalloon *s = opaque;
    int i;

    if (!s->stats_last_update) {
        error_setg(errp, "guest hasn't updated any stats yet");
        return;
    }

    visit_start_struct(v, NULL, "guest-stats", name, 0, errp);
    visit_type_int(v, &s->stats_last_update, "last-update", errp);

    visit_start_struct(v, NULL, NULL, "stats", 0, errp);
    for (i = 0; i < VIRTIO_BALLOON_S_NR; i++) {
        visit_type_int64(v, (int64_t *) &s->stats[i], balloon_stat_names[i],
                         errp);
    }
    visit_end_struct(v, errp);

    visit_end_struct(v, errp);
}

static void balloon_stats_get_poll_interval(Object *obj, struct Visitor *v,
                                            void *opaque, const char *name,
                                            Error **errp)
{
    VirtIOBalloon *s = opaque;
    visit_type_int(v, &s->stats_poll_interval, name, errp);
}

static void balloon_stats_set_poll_interval(Object *obj, struct Visitor *v,
                                            void *opaque, const char *name,
                                            Error **errp)
{
    VirtIOBalloon *s = opaque;
    int64_t value;

    visit_type_int(v, &value, name, errp);
    if (error_is_set(errp)) {
        return;
    }

    if (value < 0) {
        error_setg(errp, "timer value must be greater than zero");
        return;
    }

    if (value == s->stats_poll_interval) {
        return;
    }

    if (value == 0) {
        /* timer=0 disables the timer */
        balloon_stats_destroy_timer(s);
        return;
    }

    if (balloon_stats_enabled(s)) {
        /* timer interval change */
        s->stats_poll_interval = value;
        balloon_stats_change_timer(s, value);
        return;
    }

    /* create a new timer */
    g_assert(s->stats_timer == NULL);
    s->stats_timer = qemu_new_timer_ms(vm_clock, balloon_stats_poll_cb, s);
    s->stats_poll_interval = value;
    balloon_stats_change_timer(s, 0);
}

static void virtio_balloon_handle_output(VirtIODevice *vdev, VirtQueue *vq)
{
    VirtIOBalloon *s = VIRTIO_BALLOON(vdev);
    VirtQueueElement elem;
    MemoryRegionSection section;

    while (virtqueue_pop(vq, &elem)) {
        size_t offset = 0;
        uint32_t pfn;

        while (iov_to_buf(elem.out_sg, elem.out_num, offset, &pfn, 4) == 4) {
            ram_addr_t pa;
            ram_addr_t addr;

            pa = (ram_addr_t)ldl_p(&pfn) << VIRTIO_BALLOON_PFN_SHIFT;
            offset += 4;

            /* FIXME: remove get_system_memory(), but how? */
            section = memory_region_find(get_system_memory(), pa, 1);
            if (!int128_nz(section.size) || !memory_region_is_ram(section.mr))
                continue;

            /* Using memory_region_get_ram_ptr is bending the rules a bit, but
               should be OK because we only want a single page.  */
            addr = section.offset_within_region;
            balloon_page(memory_region_get_ram_ptr(section.mr) + addr,
                         !!(vq == s->dvq));
            memory_region_unref(section.mr);
        }

        virtqueue_push(vq, &elem, offset);
        virtio_notify(vdev, vq);
    }
}

static void virtio_balloon_receive_stats(VirtIODevice *vdev, VirtQueue *vq)
{
    VirtIOBalloon *s = VIRTIO_BALLOON(vdev);
    VirtQueueElement *elem = &s->stats_vq_elem;
    VirtIOBalloonStat stat;
    size_t offset = 0;
    qemu_timeval tv;

    if (!virtqueue_pop(vq, elem)) {
        goto out;
    }

    /* Initialize the stats to get rid of any stale values.  This is only
     * needed to handle the case where a guest supports fewer stats than it
     * used to (ie. it has booted into an old kernel).
     */
    reset_stats(s);

    while (iov_to_buf(elem->out_sg, elem->out_num, offset, &stat, sizeof(stat))
           == sizeof(stat)) {
        uint16_t tag = tswap16(stat.tag);
        uint64_t val = tswap64(stat.val);

        offset += sizeof(stat);
        if (tag < VIRTIO_BALLOON_S_NR)
            s->stats[tag] = val;
    }
    s->stats_vq_offset = offset;

    if (qemu_gettimeofday(&tv) < 0) {
        fprintf(stderr, "warning: %s: failed to get time of day\n", __func__);
        goto out;
    }

    s->stats_last_update = tv.tv_sec;

out:
    if (balloon_stats_enabled(s)) {
        balloon_stats_change_timer(s, s->stats_poll_interval);
    }
}

static void virtio_balloon_get_config(VirtIODevice *vdev, uint8_t *config_data)
{
    VirtIOBalloon *dev = VIRTIO_BALLOON(vdev);
    struct virtio_balloon_config config;

    config.num_pages = cpu_to_le32(dev->num_pages);
    config.actual = cpu_to_le32(dev->actual);

    memcpy(config_data, &config, 8);
}

static void virtio_balloon_set_config(VirtIODevice *vdev,
                                      const uint8_t *config_data)
{
    VirtIOBalloon *dev = VIRTIO_BALLOON(vdev);
    struct virtio_balloon_config config;
    uint32_t oldactual = dev->actual;
    memcpy(&config, config_data, 8);
    dev->actual = le32_to_cpu(config.actual);
    if (dev->actual != oldactual) {
        qemu_balloon_changed(ram_size -
                       ((ram_addr_t) dev->actual << VIRTIO_BALLOON_PFN_SHIFT));
    }
}

static uint32_t virtio_balloon_get_features(VirtIODevice *vdev, uint32_t f)
{
    f |= (1 << VIRTIO_BALLOON_F_STATS_VQ);
    return f;
}

static void virtio_balloon_stat(void *opaque, BalloonInfo *info)
{
    VirtIOBalloon *dev = opaque;
    info->actual = ram_size - ((uint64_t) dev->actual <<
                               VIRTIO_BALLOON_PFN_SHIFT);
}

static void virtio_balloon_to_target(void *opaque, ram_addr_t target)
{
    VirtIOBalloon *dev = VIRTIO_BALLOON(opaque);
    VirtIODevice *vdev = VIRTIO_DEVICE(dev);

    if (target > ram_size) {
        target = ram_size;
    }
    if (target) {
        dev->num_pages = (ram_size - target) >> VIRTIO_BALLOON_PFN_SHIFT;
        virtio_notify_config(vdev);
    }
}

static void virtio_balloon_save(QEMUFile *f, void *opaque)
{
    VirtIOBalloon *s = VIRTIO_BALLOON(opaque);
    VirtIODevice *vdev = VIRTIO_DEVICE(s);

    virtio_save(vdev, f);

    qemu_put_be32(f, s->num_pages);
    qemu_put_be32(f, s->actual);
}

static int virtio_balloon_load(QEMUFile *f, void *opaque, int version_id)
{
    VirtIOBalloon *s = VIRTIO_BALLOON(opaque);
    VirtIODevice *vdev = VIRTIO_DEVICE(s);
    int ret;

    if (version_id != 1)
        return -EINVAL;

    ret = virtio_load(vdev, f);
    if (ret) {
        return ret;
    }

    s->num_pages = qemu_get_be32(f);
    s->actual = qemu_get_be32(f);
    return 0;
}

static int virtio_balloon_device_init(VirtIODevice *vdev)
{
    DeviceState *qdev = DEVICE(vdev);
    VirtIOBalloon *s = VIRTIO_BALLOON(vdev);
    int ret;

    virtio_init(vdev, "virtio-balloon", VIRTIO_ID_BALLOON, 8);

    ret = qemu_add_balloon_handler(virtio_balloon_to_target,
                                   virtio_balloon_stat, s);

    if (ret < 0) {
        virtio_cleanup(VIRTIO_DEVICE(s));
        return -1;
    }

    s->ivq = virtio_add_queue(vdev, 128, virtio_balloon_handle_output);
    s->dvq = virtio_add_queue(vdev, 128, virtio_balloon_handle_output);
    s->svq = virtio_add_queue(vdev, 128, virtio_balloon_receive_stats);

    register_savevm(qdev, "virtio-balloon", -1, 1,
                    virtio_balloon_save, virtio_balloon_load, s);

    object_property_add(OBJECT(qdev), "guest-stats", "guest statistics",
                        balloon_stats_get_all, NULL, NULL, s, NULL);

    object_property_add(OBJECT(qdev), "guest-stats-polling-interval", "int",
                        balloon_stats_get_poll_interval,
                        balloon_stats_set_poll_interval,
                        NULL, s, NULL);
    return 0;
}

static int virtio_balloon_device_exit(DeviceState *qdev)
{
    VirtIOBalloon *s = VIRTIO_BALLOON(qdev);
    VirtIODevice *vdev = VIRTIO_DEVICE(qdev);

    balloon_stats_destroy_timer(s);
    qemu_remove_balloon_handler(s);
    unregister_savevm(qdev, "virtio-balloon", s);
    virtio_cleanup(vdev);
    return 0;
}

static Property virtio_balloon_properties[] = {
    DEFINE_PROP_END_OF_LIST(),
};

static void virtio_balloon_class_init(ObjectClass *klass, void *data)
{
    DeviceClass *dc = DEVICE_CLASS(klass);
    VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
    dc->exit = virtio_balloon_device_exit;
    dc->props = virtio_balloon_properties;
    vdc->init = virtio_balloon_device_init;
    vdc->get_config = virtio_balloon_get_config;
    vdc->set_config = virtio_balloon_set_config;
    vdc->get_features = virtio_balloon_get_features;
}

static const TypeInfo virtio_balloon_info = {
    .name = TYPE_VIRTIO_BALLOON,
    .parent = TYPE_VIRTIO_DEVICE,
    .instance_size = sizeof(VirtIOBalloon),
    .class_init = virtio_balloon_class_init,
};

static void virtio_register_types(void)
{
    type_register_static(&virtio_balloon_info);
}

type_init(virtio_register_types)
Commit	Line	Data
bd322087	1	/*
d4443cb6	2	* Virtio Balloon Device
bd322087 AL	3	*
bd322087 AL	4	* Copyright IBM, Corp. 2008
d4443cb6 AS	5	* Copyright (C) 2011 Red Hat, Inc.
d4443cb6 AS	6	* Copyright (C) 2011 Amit Shah <amit.shah@redhat.com>
bd322087 AL	7	*
	8	* Authors:
	9	* Anthony Liguori <aliguori@us.ibm.com>
	10	*
	11	* This work is licensed under the terms of the GNU GPL, version 2. See
	12	* the COPYING file in the top-level directory.
	13	*
	14	*/
	15
1de7afc9	16	#include "qemu/iov.h"
7e6ccd9c	17	#include "qemu/timer.h"
bd322087	18	#include "qemu-common.h"
0d09e41a PB	19	#include "hw/virtio/virtio.h"
0d09e41a PB	20	#include "hw/i386/pc.h"
bd322087	21	#include "cpu.h"
9c17d615	22	#include "sysemu/balloon.h"
0d09e41a	23	#include "hw/virtio/virtio-balloon.h"
9c17d615	24	#include "sysemu/kvm.h"
022c62cb	25	#include "exec/address-spaces.h"
7e6ccd9c	26	#include "qapi/visitor.h"
bd322087 AL	27
	28	#if defined(__linux__)
	29	#include <sys/mman.h>
	30	#endif
	31
0d09e41a	32	#include "hw/virtio/virtio-bus.h"
1ab461b5	33
bd322087 AL	34	static void balloon_page(void *addr, int deflate)
	35	{
	36	#if defined(__linux__)
	37	if (!kvm_enabled() \|\| kvm_has_sync_mmu())
e78815a5 AF	38	qemu_madvise(addr, TARGET_PAGE_SIZE,
e78815a5 AF	39	deflate ? QEMU_MADV_WILLNEED : QEMU_MADV_DONTNEED);
bd322087 AL	40	#endif
	41	}
	42
7e6ccd9c LC	43	static const char *balloon_stat_names[] = {
	44	[VIRTIO_BALLOON_S_SWAP_IN] = "stat-swap-in",
	45	[VIRTIO_BALLOON_S_SWAP_OUT] = "stat-swap-out",
	46	[VIRTIO_BALLOON_S_MAJFLT] = "stat-major-faults",
	47	[VIRTIO_BALLOON_S_MINFLT] = "stat-minor-faults",
	48	[VIRTIO_BALLOON_S_MEMFREE] = "stat-free-memory",
	49	[VIRTIO_BALLOON_S_MEMTOT] = "stat-total-memory",
	50	[VIRTIO_BALLOON_S_NR] = NULL
	51	};
	52
625a5bef AL	53	/*
	54	* reset_stats - Mark all items in the stats array as unset
	55	*
	56	* This function needs to be called at device intialization and before
	57	* before updating to a set of newly-generated stats. This will ensure that no
	58	* stale values stick around in case the guest reports a subset of the supported
	59	* statistics.
	60	*/
	61	static inline void reset_stats(VirtIOBalloon *dev)
	62	{
	63	int i;
	64	for (i = 0; i < VIRTIO_BALLOON_S_NR; dev->stats[i++] = -1);
	65	}
	66
7e6ccd9c LC	67	static bool balloon_stats_supported(const VirtIOBalloon *s)
7e6ccd9c LC	68	{
c96caced KF	69	VirtIODevice *vdev = VIRTIO_DEVICE(s);
c96caced KF	70	return vdev->guest_features & (1 << VIRTIO_BALLOON_F_STATS_VQ);
7e6ccd9c LC	71	}
	72
	73	static bool balloon_stats_enabled(const VirtIOBalloon *s)
	74	{
	75	return s->stats_poll_interval > 0;
	76	}
	77
	78	static void balloon_stats_destroy_timer(VirtIOBalloon *s)
	79	{
	80	if (balloon_stats_enabled(s)) {
	81	qemu_del_timer(s->stats_timer);
	82	qemu_free_timer(s->stats_timer);
	83	s->stats_timer = NULL;
	84	s->stats_poll_interval = 0;
	85	}
	86	}
	87
	88	static void balloon_stats_change_timer(VirtIOBalloon *s, int secs)
	89	{
	90	qemu_mod_timer(s->stats_timer, qemu_get_clock_ms(vm_clock) + secs * 1000);
	91	}
	92
	93	static void balloon_stats_poll_cb(void *opaque)
	94	{
	95	VirtIOBalloon *s = opaque;
c96caced	96	VirtIODevice *vdev = VIRTIO_DEVICE(s);
7e6ccd9c LC	97
	98	if (!balloon_stats_supported(s)) {
	99	/* re-schedule */
	100	balloon_stats_change_timer(s, s->stats_poll_interval);
	101	return;
	102	}
	103
	104	virtqueue_push(s->svq, &s->stats_vq_elem, s->stats_vq_offset);
c96caced	105	virtio_notify(vdev, s->svq);
7e6ccd9c LC	106	}
	107
	108	static void balloon_stats_get_all(Object obj, struct Visitor v,
	109	void opaque, const char name, Error **errp)
	110	{
	111	VirtIOBalloon *s = opaque;
	112	int i;
	113
	114	if (!s->stats_last_update) {
	115	error_setg(errp, "guest hasn't updated any stats yet");
	116	return;
	117	}
	118
	119	visit_start_struct(v, NULL, "guest-stats", name, 0, errp);
	120	visit_type_int(v, &s->stats_last_update, "last-update", errp);
	121
	122	visit_start_struct(v, NULL, NULL, "stats", 0, errp);
	123	for (i = 0; i < VIRTIO_BALLOON_S_NR; i++) {
	124	visit_type_int64(v, (int64_t *) &s->stats[i], balloon_stat_names[i],
	125	errp);
	126	}
	127	visit_end_struct(v, errp);
	128
	129	visit_end_struct(v, errp);
	130	}
	131
	132	static void balloon_stats_get_poll_interval(Object obj, struct Visitor v,
	133	void opaque, const char name,
	134	Error **errp)
	135	{
	136	VirtIOBalloon *s = opaque;
	137	visit_type_int(v, &s->stats_poll_interval, name, errp);
	138	}
	139
	140	static void balloon_stats_set_poll_interval(Object obj, struct Visitor v,
	141	void opaque, const char name,
	142	Error **errp)
	143	{
	144	VirtIOBalloon *s = opaque;
	145	int64_t value;
	146
	147	visit_type_int(v, &value, name, errp);
	148	if (error_is_set(errp)) {
	149	return;
	150	}
	151
	152	if (value < 0) {
	153	error_setg(errp, "timer value must be greater than zero");
	154	return;
	155	}
	156
	157	if (value == s->stats_poll_interval) {
	158	return;
	159	}
	160
	161	if (value == 0) {
	162	/* timer=0 disables the timer */
	163	balloon_stats_destroy_timer(s);
	164	return;
	165	}
	166
	167	if (balloon_stats_enabled(s)) {
	168	/* timer interval change */
	169	s->stats_poll_interval = value;
170	balloon_stats_change_timer(s, value);
171	return;
172	}
173
174	/* create a new timer */
175	g_assert(s->stats_timer == NULL);
176	s->stats_timer = qemu_new_timer_ms(vm_clock, balloon_stats_poll_cb, s);
177	s->stats_poll_interval = value;
178	balloon_stats_change_timer(s, 0);
179	}
180
bd322087 AL	181	static void virtio_balloon_handle_output(VirtIODevice vdev, VirtQueue vq)
bd322087 AL	182	{
c96caced	183	VirtIOBalloon *s = VIRTIO_BALLOON(vdev);
bd322087	184	VirtQueueElement elem;
b7c28c74	185	MemoryRegionSection section;
bd322087 AL	186
	187	while (virtqueue_pop(vq, &elem)) {
	188	size_t offset = 0;
	189	uint32_t pfn;
	190
dcf6f5e1	191	while (iov_to_buf(elem.out_sg, elem.out_num, offset, &pfn, 4) == 4) {
c227f099 AL	192	ram_addr_t pa;
c227f099 AL	193	ram_addr_t addr;
bd322087	194
c227f099	195	pa = (ram_addr_t)ldl_p(&pfn) << VIRTIO_BALLOON_PFN_SHIFT;
bd322087 AL	196	offset += 4;
bd322087 AL	197
b7c28c74 AK	198	/* FIXME: remove get_system_memory(), but how? */
b7c28c74 AK	199	section = memory_region_find(get_system_memory(), pa, 1);
052e87b0	200	if (!int128_nz(section.size) \|\| !memory_region_is_ram(section.mr))
bd322087 AL	201	continue;
bd322087 AL	202
b7c28c74	203	/* Using memory_region_get_ram_ptr is bending the rules a bit, but
5c130f65	204	should be OK because we only want a single page. */
b7c28c74 AK	205	addr = section.offset_within_region;
	206	balloon_page(memory_region_get_ram_ptr(section.mr) + addr,
	207	!!(vq == s->dvq));
dfde4e6e	208	memory_region_unref(section.mr);
bd322087 AL	209	}
	210
	211	virtqueue_push(vq, &elem, offset);
	212	virtio_notify(vdev, vq);
	213	}
	214	}
	215
625a5bef AL	216	static void virtio_balloon_receive_stats(VirtIODevice vdev, VirtQueue vq)
625a5bef AL	217	{
c96caced	218	VirtIOBalloon *s = VIRTIO_BALLOON(vdev);
625a5bef AL	219	VirtQueueElement *elem = &s->stats_vq_elem;
	220	VirtIOBalloonStat stat;
	221	size_t offset = 0;
7e6ccd9c	222	qemu_timeval tv;
625a5bef AL	223
625a5bef AL	224	if (!virtqueue_pop(vq, elem)) {
7e6ccd9c	225	goto out;
625a5bef AL	226	}
	227
	228	/* Initialize the stats to get rid of any stale values. This is only
	229	* needed to handle the case where a guest supports fewer stats than it
	230	* used to (ie. it has booted into an old kernel).
	231	*/
	232	reset_stats(s);
	233
dcf6f5e1	234	while (iov_to_buf(elem->out_sg, elem->out_num, offset, &stat, sizeof(stat))
fa6111f2	235	== sizeof(stat)) {
625a5bef AL	236	uint16_t tag = tswap16(stat.tag);
	237	uint64_t val = tswap64(stat.val);
	238
	239	offset += sizeof(stat);
	240	if (tag < VIRTIO_BALLOON_S_NR)
	241	s->stats[tag] = val;
	242	}
	243	s->stats_vq_offset = offset;
7e6ccd9c LC	244
	245	if (qemu_gettimeofday(&tv) < 0) {
	246	fprintf(stderr, "warning: %s: failed to get time of day\n", __func__);
	247	goto out;
	248	}
	249
	250	s->stats_last_update = tv.tv_sec;
	251
	252	out:
	253	if (balloon_stats_enabled(s)) {
	254	balloon_stats_change_timer(s, s->stats_poll_interval);
	255	}
625a5bef AL	256	}
625a5bef AL	257
bd322087 AL	258	static void virtio_balloon_get_config(VirtIODevice vdev, uint8_t config_data)
bd322087 AL	259	{
c96caced	260	VirtIOBalloon *dev = VIRTIO_BALLOON(vdev);
bd322087 AL	261	struct virtio_balloon_config config;
	262
	263	config.num_pages = cpu_to_le32(dev->num_pages);
	264	config.actual = cpu_to_le32(dev->actual);
	265
	266	memcpy(config_data, &config, 8);
	267	}
	268
	269	static void virtio_balloon_set_config(VirtIODevice *vdev,
	270	const uint8_t *config_data)
	271	{
c96caced	272	VirtIOBalloon *dev = VIRTIO_BALLOON(vdev);
bd322087	273	struct virtio_balloon_config config;
973603a8	274	uint32_t oldactual = dev->actual;
bd322087	275	memcpy(&config, config_data, 8);
e54f1771	276	dev->actual = le32_to_cpu(config.actual);
973603a8 DB	277	if (dev->actual != oldactual) {
973603a8 DB	278	qemu_balloon_changed(ram_size -
dcc6ceff	279	((ram_addr_t) dev->actual << VIRTIO_BALLOON_PFN_SHIFT));
973603a8	280	}
bd322087 AL	281	}
bd322087 AL	282
8172539d	283	static uint32_t virtio_balloon_get_features(VirtIODevice *vdev, uint32_t f)
bd322087	284	{
625a5bef	285	f \|= (1 << VIRTIO_BALLOON_F_STATS_VQ);
8172539d	286	return f;
bd322087 AL	287	}
bd322087 AL	288
96637bcd	289	static void virtio_balloon_stat(void opaque, BalloonInfo info)
dce911c7 AS	290	{
dce911c7 AS	291	VirtIOBalloon *dev = opaque;
96637bcd LC	292	info->actual = ram_size - ((uint64_t) dev->actual <<
96637bcd LC	293	VIRTIO_BALLOON_PFN_SHIFT);
dce911c7 AS	294	}
dce911c7 AS	295
30fb2ca6	296	static void virtio_balloon_to_target(void *opaque, ram_addr_t target)
bd322087	297	{
c96caced KF	298	VirtIOBalloon *dev = VIRTIO_BALLOON(opaque);
c96caced KF	299	VirtIODevice *vdev = VIRTIO_DEVICE(dev);
bd322087	300
dce911c7	301	if (target > ram_size) {
bd322087	302	target = ram_size;
dce911c7	303	}
bd322087 AL	304	if (target) {
bd322087 AL	305	dev->num_pages = (ram_size - target) >> VIRTIO_BALLOON_PFN_SHIFT;
c96caced	306	virtio_notify_config(vdev);
bd322087	307	}
bd322087 AL	308	}
	309
	310	static void virtio_balloon_save(QEMUFile f, void opaque)
	311	{
c96caced KF	312	VirtIOBalloon *s = VIRTIO_BALLOON(opaque);
c96caced KF	313	VirtIODevice *vdev = VIRTIO_DEVICE(s);
bd322087	314
c96caced	315	virtio_save(vdev, f);
bd322087 AL	316
	317	qemu_put_be32(f, s->num_pages);
	318	qemu_put_be32(f, s->actual);
	319	}
	320
	321	static int virtio_balloon_load(QEMUFile f, void opaque, int version_id)
	322	{
c96caced KF	323	VirtIOBalloon *s = VIRTIO_BALLOON(opaque);
c96caced KF	324	VirtIODevice *vdev = VIRTIO_DEVICE(s);
2a633c46	325	int ret;
bd322087 AL	326
	327	if (version_id != 1)
	328	return -EINVAL;
	329
c96caced	330	ret = virtio_load(vdev, f);
2a633c46 OW	331	if (ret) {
	332	return ret;
	333	}
bd322087 AL	334
	335	s->num_pages = qemu_get_be32(f);
	336	s->actual = qemu_get_be32(f);
bd322087 AL	337	return 0;
	338	}
	339
5c7d0962	340	static int virtio_balloon_device_init(VirtIODevice *vdev)
bd322087	341	{
5c7d0962 KF	342	DeviceState *qdev = DEVICE(vdev);
5c7d0962 KF	343	VirtIOBalloon *s = VIRTIO_BALLOON(vdev);
f76f6655	344	int ret;
bd322087	345
5c7d0962	346	virtio_init(vdev, "virtio-balloon", VIRTIO_ID_BALLOON, 8);
bd322087	347
f76f6655 AS	348	ret = qemu_add_balloon_handler(virtio_balloon_to_target,
f76f6655 AS	349	virtio_balloon_stat, s);
5c7d0962	350
1ab461b5	351	if (ret < 0) {
6a1a8cc7	352	virtio_cleanup(VIRTIO_DEVICE(s));
5c7d0962	353	return -1;
1ab461b5	354	}
f76f6655	355
5c7d0962 KF	356	s->ivq = virtio_add_queue(vdev, 128, virtio_balloon_handle_output);
	357	s->dvq = virtio_add_queue(vdev, 128, virtio_balloon_handle_output);
	358	s->svq = virtio_add_queue(vdev, 128, virtio_balloon_receive_stats);
bd322087	359
5c7d0962	360	register_savevm(qdev, "virtio-balloon", -1, 1,
0be71e32	361	virtio_balloon_save, virtio_balloon_load, s);
bd322087	362
5c7d0962	363	object_property_add(OBJECT(qdev), "guest-stats", "guest statistics",
7e6ccd9c LC	364	balloon_stats_get_all, NULL, NULL, s, NULL);
7e6ccd9c LC	365
5c7d0962	366	object_property_add(OBJECT(qdev), "guest-stats-polling-interval", "int",
7e6ccd9c LC	367	balloon_stats_get_poll_interval,
	368	balloon_stats_set_poll_interval,
	369	NULL, s, NULL);
1ab461b5 KF	370	return 0;
	371	}
	372
	373	static int virtio_balloon_device_exit(DeviceState *qdev)
	374	{
	375	VirtIOBalloon *s = VIRTIO_BALLOON(qdev);
	376	VirtIODevice *vdev = VIRTIO_DEVICE(qdev);
	377
	378	balloon_stats_destroy_timer(s);
	379	qemu_remove_balloon_handler(s);
	380	unregister_savevm(qdev, "virtio-balloon", s);
6a1a8cc7	381	virtio_cleanup(vdev);
1ab461b5 KF	382	return 0;
	383	}
	384
	385	static Property virtio_balloon_properties[] = {
	386	DEFINE_PROP_END_OF_LIST(),
	387	};
	388
	389	static void virtio_balloon_class_init(ObjectClass klass, void data)
	390	{
	391	DeviceClass *dc = DEVICE_CLASS(klass);
	392	VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
	393	dc->exit = virtio_balloon_device_exit;
	394	dc->props = virtio_balloon_properties;
	395	vdc->init = virtio_balloon_device_init;
	396	vdc->get_config = virtio_balloon_get_config;
	397	vdc->set_config = virtio_balloon_set_config;
	398	vdc->get_features = virtio_balloon_get_features;
	399	}
	400
	401	static const TypeInfo virtio_balloon_info = {
	402	.name = TYPE_VIRTIO_BALLOON,
	403	.parent = TYPE_VIRTIO_DEVICE,
	404	.instance_size = sizeof(VirtIOBalloon),
	405	.class_init = virtio_balloon_class_init,
	406	};
	407
	408	static void virtio_register_types(void)
	409	{
	410	type_register_static(&virtio_balloon_info);
	411	}
	412
	413	type_init(virtio_register_types)