blob: 884570a57d1f6dcc81eacd5971c449431d49dc7c [file] [log] [blame]
aliguoribd322082008-12-04 20:33:06 +00001/*
Amit Shahd4443cb2011-07-20 13:37:01 +05302 * Virtio Balloon Device
aliguoribd322082008-12-04 20:33:06 +00003 *
4 * Copyright IBM, Corp. 2008
Amit Shahd4443cb2011-07-20 13:37:01 +05305 * Copyright (C) 2011 Red Hat, Inc.
6 * Copyright (C) 2011 Amit Shah <amit.shah@redhat.com>
aliguoribd322082008-12-04 20:33:06 +00007 *
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
Peter Maydell9b8bfe22016-01-26 18:17:07 +000016#include "qemu/osdep.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010017#include "qemu/iov.h"
Luiz Capitulino7e6ccd92012-12-01 00:14:57 -020018#include "qemu/timer.h"
aliguoribd322082008-12-04 20:33:06 +000019#include "qemu-common.h"
Paolo Bonzini0d09e412013-02-05 17:06:20 +010020#include "hw/virtio/virtio.h"
21#include "hw/i386/pc.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010022#include "sysemu/balloon.h"
Paolo Bonzini0d09e412013-02-05 17:06:20 +010023#include "hw/virtio/virtio-balloon.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010024#include "sysemu/kvm.h"
Paolo Bonzini022c62c2012-12-17 18:19:49 +010025#include "exec/address-spaces.h"
Luiz Capitulino7e6ccd92012-12-01 00:14:57 -020026#include "qapi/visitor.h"
Wenchao Xiaaef9d312014-06-18 08:43:51 +020027#include "qapi-event.h"
zhanghailiang6adfdc52014-11-17 13:11:10 +080028#include "trace.h"
aliguoribd322082008-12-04 20:33:06 +000029
Paolo Bonzini0d09e412013-02-05 17:06:20 +010030#include "hw/virtio/virtio-bus.h"
Rusty Russell8609d2a2014-06-24 19:43:22 +020031#include "hw/virtio/virtio-access.h"
KONRAD Frederic1ab461b2013-03-27 10:49:10 +010032
Thomas Huth01310e22016-04-14 10:50:07 +020033#define BALLOON_PAGE_SIZE (1 << VIRTIO_BALLOON_PFN_SHIFT)
34
aliguoribd322082008-12-04 20:33:06 +000035static void balloon_page(void *addr, int deflate)
36{
Dr. David Alan Gilbert371ff5a2015-11-05 18:11:23 +000037 if (!qemu_balloon_is_inhibited() && (!kvm_enabled() ||
38 kvm_has_sync_mmu())) {
Thomas Huth01310e22016-04-14 10:50:07 +020039 qemu_madvise(addr, BALLOON_PAGE_SIZE,
Andreas Färbere78815a2010-09-25 11:26:05 +000040 deflate ? QEMU_MADV_WILLNEED : QEMU_MADV_DONTNEED);
Dr. David Alan Gilbert371ff5a2015-11-05 18:11:23 +000041 }
aliguoribd322082008-12-04 20:33:06 +000042}
43
Luiz Capitulino7e6ccd92012-12-01 00:14:57 -020044static const char *balloon_stat_names[] = {
45 [VIRTIO_BALLOON_S_SWAP_IN] = "stat-swap-in",
46 [VIRTIO_BALLOON_S_SWAP_OUT] = "stat-swap-out",
47 [VIRTIO_BALLOON_S_MAJFLT] = "stat-major-faults",
48 [VIRTIO_BALLOON_S_MINFLT] = "stat-minor-faults",
49 [VIRTIO_BALLOON_S_MEMFREE] = "stat-free-memory",
50 [VIRTIO_BALLOON_S_MEMTOT] = "stat-total-memory",
Denis V. Luneva0d06482016-02-24 10:50:48 +030051 [VIRTIO_BALLOON_S_AVAIL] = "stat-available-memory",
Luiz Capitulino7e6ccd92012-12-01 00:14:57 -020052 [VIRTIO_BALLOON_S_NR] = NULL
53};
54
Adam Litke625a5be2010-01-26 14:17:35 -060055/*
56 * reset_stats - Mark all items in the stats array as unset
57 *
Stefan Weil52f35022013-07-24 19:48:56 +020058 * This function needs to be called at device initialization and before
59 * updating to a set of newly-generated stats. This will ensure that no
Adam Litke625a5be2010-01-26 14:17:35 -060060 * stale values stick around in case the guest reports a subset of the supported
61 * statistics.
62 */
63static inline void reset_stats(VirtIOBalloon *dev)
64{
65 int i;
66 for (i = 0; i < VIRTIO_BALLOON_S_NR; dev->stats[i++] = -1);
67}
68
Luiz Capitulino7e6ccd92012-12-01 00:14:57 -020069static bool balloon_stats_supported(const VirtIOBalloon *s)
70{
KONRAD Fredericc96cace2013-03-27 10:49:14 +010071 VirtIODevice *vdev = VIRTIO_DEVICE(s);
Cornelia Huck95129d62015-08-17 11:48:29 +020072 return virtio_vdev_has_feature(vdev, VIRTIO_BALLOON_F_STATS_VQ);
Luiz Capitulino7e6ccd92012-12-01 00:14:57 -020073}
74
75static bool balloon_stats_enabled(const VirtIOBalloon *s)
76{
77 return s->stats_poll_interval > 0;
78}
79
80static void balloon_stats_destroy_timer(VirtIOBalloon *s)
81{
82 if (balloon_stats_enabled(s)) {
Alex Blighbc72ad62013-08-21 16:03:08 +010083 timer_del(s->stats_timer);
84 timer_free(s->stats_timer);
Luiz Capitulino7e6ccd92012-12-01 00:14:57 -020085 s->stats_timer = NULL;
86 s->stats_poll_interval = 0;
87 }
88}
89
Luiz Capitulino1f9296b2014-09-15 12:00:11 -040090static void balloon_stats_change_timer(VirtIOBalloon *s, int64_t secs)
Luiz Capitulino7e6ccd92012-12-01 00:14:57 -020091{
Alex Blighbc72ad62013-08-21 16:03:08 +010092 timer_mod(s->stats_timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) + secs * 1000);
Luiz Capitulino7e6ccd92012-12-01 00:14:57 -020093}
94
95static void balloon_stats_poll_cb(void *opaque)
96{
97 VirtIOBalloon *s = opaque;
KONRAD Fredericc96cace2013-03-27 10:49:14 +010098 VirtIODevice *vdev = VIRTIO_DEVICE(s);
Luiz Capitulino7e6ccd92012-12-01 00:14:57 -020099
Ladi Prosek4eae2a62016-03-01 12:14:03 +0100100 if (s->stats_vq_elem == NULL || !balloon_stats_supported(s)) {
Luiz Capitulino7e6ccd92012-12-01 00:14:57 -0200101 /* re-schedule */
102 balloon_stats_change_timer(s, s->stats_poll_interval);
103 return;
104 }
105
Paolo Bonzini51b19eb2016-02-04 16:26:51 +0200106 virtqueue_push(s->svq, s->stats_vq_elem, s->stats_vq_offset);
KONRAD Fredericc96cace2013-03-27 10:49:14 +0100107 virtio_notify(vdev, s->svq);
Paolo Bonzini51b19eb2016-02-04 16:26:51 +0200108 g_free(s->stats_vq_elem);
109 s->stats_vq_elem = NULL;
Luiz Capitulino7e6ccd92012-12-01 00:14:57 -0200110}
111
Eric Blaked7bce992016-01-29 06:48:55 -0700112static void balloon_stats_get_all(Object *obj, Visitor *v, const char *name,
113 void *opaque, Error **errp)
Luiz Capitulino7e6ccd92012-12-01 00:14:57 -0200114{
Markus Armbruster2ddb16a2014-05-07 09:53:52 +0200115 Error *err = NULL;
Luiz Capitulino7e6ccd92012-12-01 00:14:57 -0200116 VirtIOBalloon *s = opaque;
117 int i;
118
Eric Blake337283d2016-01-29 06:48:57 -0700119 visit_start_struct(v, name, NULL, 0, &err);
Markus Armbruster2ddb16a2014-05-07 09:53:52 +0200120 if (err) {
121 goto out;
122 }
Eric Blake51e72bc2016-01-29 06:48:54 -0700123 visit_type_int(v, "last-update", &s->stats_last_update, &err);
Markus Armbruster297a3642014-05-07 09:53:54 +0200124 if (err) {
125 goto out_end;
126 }
Markus Armbruster2ddb16a2014-05-07 09:53:52 +0200127
Eric Blake337283d2016-01-29 06:48:57 -0700128 visit_start_struct(v, "stats", NULL, 0, &err);
Markus Armbruster2ddb16a2014-05-07 09:53:52 +0200129 if (err) {
130 goto out_end;
131 }
Eric Blake9dbb8fa2016-01-29 06:48:45 -0700132 for (i = 0; i < VIRTIO_BALLOON_S_NR; i++) {
Eric Blake51e72bc2016-01-29 06:48:54 -0700133 visit_type_uint64(v, balloon_stat_names[i], &s->stats[i], &err);
Eric Blake9dbb8fa2016-01-29 06:48:45 -0700134 if (err) {
Eric Blake15c2f662016-04-28 15:45:27 -0600135 goto out_nested;
Eric Blake9dbb8fa2016-01-29 06:48:45 -0700136 }
Luiz Capitulino7e6ccd92012-12-01 00:14:57 -0200137 }
Eric Blake15c2f662016-04-28 15:45:27 -0600138 visit_check_struct(v, &err);
139out_nested:
Eric Blake1158bb22016-06-09 10:48:34 -0600140 visit_end_struct(v, NULL);
Luiz Capitulino7e6ccd92012-12-01 00:14:57 -0200141
Eric Blake15c2f662016-04-28 15:45:27 -0600142 if (!err) {
143 visit_check_struct(v, &err);
144 }
Markus Armbruster2ddb16a2014-05-07 09:53:52 +0200145out_end:
Eric Blake1158bb22016-06-09 10:48:34 -0600146 visit_end_struct(v, NULL);
Markus Armbruster2ddb16a2014-05-07 09:53:52 +0200147out:
148 error_propagate(errp, err);
Luiz Capitulino7e6ccd92012-12-01 00:14:57 -0200149}
150
Eric Blake4fa45492016-01-29 06:48:53 -0700151static void balloon_stats_get_poll_interval(Object *obj, Visitor *v,
Eric Blaked7bce992016-01-29 06:48:55 -0700152 const char *name, void *opaque,
Luiz Capitulino7e6ccd92012-12-01 00:14:57 -0200153 Error **errp)
154{
155 VirtIOBalloon *s = opaque;
Eric Blake51e72bc2016-01-29 06:48:54 -0700156 visit_type_int(v, name, &s->stats_poll_interval, errp);
Luiz Capitulino7e6ccd92012-12-01 00:14:57 -0200157}
158
Eric Blake4fa45492016-01-29 06:48:53 -0700159static void balloon_stats_set_poll_interval(Object *obj, Visitor *v,
Eric Blaked7bce992016-01-29 06:48:55 -0700160 const char *name, void *opaque,
Luiz Capitulino7e6ccd92012-12-01 00:14:57 -0200161 Error **errp)
162{
163 VirtIOBalloon *s = opaque;
Markus Armbruster65cd9062014-04-25 12:44:22 +0200164 Error *local_err = NULL;
Luiz Capitulino7e6ccd92012-12-01 00:14:57 -0200165 int64_t value;
166
Eric Blake51e72bc2016-01-29 06:48:54 -0700167 visit_type_int(v, name, &value, &local_err);
Markus Armbruster65cd9062014-04-25 12:44:22 +0200168 if (local_err) {
169 error_propagate(errp, local_err);
Luiz Capitulino7e6ccd92012-12-01 00:14:57 -0200170 return;
171 }
172
173 if (value < 0) {
174 error_setg(errp, "timer value must be greater than zero");
175 return;
176 }
177
Markus Armbruster22644cd2014-10-01 18:43:44 +0200178 if (value > UINT32_MAX) {
Luiz Capitulino1f9296b2014-09-15 12:00:11 -0400179 error_setg(errp, "timer value is too big");
180 return;
181 }
182
Luiz Capitulino7e6ccd92012-12-01 00:14:57 -0200183 if (value == s->stats_poll_interval) {
184 return;
185 }
186
187 if (value == 0) {
188 /* timer=0 disables the timer */
189 balloon_stats_destroy_timer(s);
190 return;
191 }
192
193 if (balloon_stats_enabled(s)) {
194 /* timer interval change */
195 s->stats_poll_interval = value;
196 balloon_stats_change_timer(s, value);
197 return;
198 }
199
200 /* create a new timer */
201 g_assert(s->stats_timer == NULL);
Alex Blighbc72ad62013-08-21 16:03:08 +0100202 s->stats_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL, balloon_stats_poll_cb, s);
Luiz Capitulino7e6ccd92012-12-01 00:14:57 -0200203 s->stats_poll_interval = value;
204 balloon_stats_change_timer(s, 0);
205}
206
aliguoribd322082008-12-04 20:33:06 +0000207static void virtio_balloon_handle_output(VirtIODevice *vdev, VirtQueue *vq)
208{
KONRAD Fredericc96cace2013-03-27 10:49:14 +0100209 VirtIOBalloon *s = VIRTIO_BALLOON(vdev);
Paolo Bonzini51b19eb2016-02-04 16:26:51 +0200210 VirtQueueElement *elem;
Avi Kivityb7c28c72011-12-19 13:18:13 +0200211 MemoryRegionSection section;
aliguoribd322082008-12-04 20:33:06 +0000212
Paolo Bonzini51b19eb2016-02-04 16:26:51 +0200213 for (;;) {
aliguoribd322082008-12-04 20:33:06 +0000214 size_t offset = 0;
215 uint32_t pfn;
Paolo Bonzini51b19eb2016-02-04 16:26:51 +0200216 elem = virtqueue_pop(vq, sizeof(VirtQueueElement));
217 if (!elem) {
218 return;
219 }
aliguoribd322082008-12-04 20:33:06 +0000220
Paolo Bonzini51b19eb2016-02-04 16:26:51 +0200221 while (iov_to_buf(elem->out_sg, elem->out_num, offset, &pfn, 4) == 4) {
Anthony Liguoric227f092009-10-01 16:12:16 -0500222 ram_addr_t pa;
223 ram_addr_t addr;
Rusty Russell8609d2a2014-06-24 19:43:22 +0200224 int p = virtio_ldl_p(vdev, &pfn);
aliguoribd322082008-12-04 20:33:06 +0000225
Rusty Russell8609d2a2014-06-24 19:43:22 +0200226 pa = (ram_addr_t) p << VIRTIO_BALLOON_PFN_SHIFT;
aliguoribd322082008-12-04 20:33:06 +0000227 offset += 4;
228
Avi Kivityb7c28c72011-12-19 13:18:13 +0200229 /* FIXME: remove get_system_memory(), but how? */
230 section = memory_region_find(get_system_memory(), pa, 1);
Paolo Bonzini052e87b2013-05-27 10:08:27 +0200231 if (!int128_nz(section.size) || !memory_region_is_ram(section.mr))
aliguoribd322082008-12-04 20:33:06 +0000232 continue;
233
zhanghailiang6adfdc52014-11-17 13:11:10 +0800234 trace_virtio_balloon_handle_output(memory_region_name(section.mr),
235 pa);
Avi Kivityb7c28c72011-12-19 13:18:13 +0200236 /* Using memory_region_get_ram_ptr is bending the rules a bit, but
pbrook5c130f62009-04-10 14:29:45 +0000237 should be OK because we only want a single page. */
Avi Kivityb7c28c72011-12-19 13:18:13 +0200238 addr = section.offset_within_region;
239 balloon_page(memory_region_get_ram_ptr(section.mr) + addr,
240 !!(vq == s->dvq));
Paolo Bonzinidfde4e62013-05-06 10:46:11 +0200241 memory_region_unref(section.mr);
aliguoribd322082008-12-04 20:33:06 +0000242 }
243
Paolo Bonzini51b19eb2016-02-04 16:26:51 +0200244 virtqueue_push(vq, elem, offset);
aliguoribd322082008-12-04 20:33:06 +0000245 virtio_notify(vdev, vq);
Paolo Bonzini51b19eb2016-02-04 16:26:51 +0200246 g_free(elem);
aliguoribd322082008-12-04 20:33:06 +0000247 }
248}
249
Adam Litke625a5be2010-01-26 14:17:35 -0600250static void virtio_balloon_receive_stats(VirtIODevice *vdev, VirtQueue *vq)
251{
KONRAD Fredericc96cace2013-03-27 10:49:14 +0100252 VirtIOBalloon *s = VIRTIO_BALLOON(vdev);
Paolo Bonzini51b19eb2016-02-04 16:26:51 +0200253 VirtQueueElement *elem;
Adam Litke625a5be2010-01-26 14:17:35 -0600254 VirtIOBalloonStat stat;
255 size_t offset = 0;
Luiz Capitulino7e6ccd92012-12-01 00:14:57 -0200256 qemu_timeval tv;
Adam Litke625a5be2010-01-26 14:17:35 -0600257
Ladi Prosek4eae2a62016-03-01 12:14:03 +0100258 elem = virtqueue_pop(vq, sizeof(VirtQueueElement));
Paolo Bonzini51b19eb2016-02-04 16:26:51 +0200259 if (!elem) {
Luiz Capitulino7e6ccd92012-12-01 00:14:57 -0200260 goto out;
Adam Litke625a5be2010-01-26 14:17:35 -0600261 }
262
Ladi Prosek4eae2a62016-03-01 12:14:03 +0100263 if (s->stats_vq_elem != NULL) {
264 /* This should never happen if the driver follows the spec. */
265 virtqueue_push(vq, s->stats_vq_elem, 0);
266 virtio_notify(vdev, vq);
267 g_free(s->stats_vq_elem);
268 }
269
270 s->stats_vq_elem = elem;
271
Adam Litke625a5be2010-01-26 14:17:35 -0600272 /* Initialize the stats to get rid of any stale values. This is only
273 * needed to handle the case where a guest supports fewer stats than it
274 * used to (ie. it has booted into an old kernel).
275 */
276 reset_stats(s);
277
Michael Tokarevdcf6f5e2012-03-11 18:05:12 +0400278 while (iov_to_buf(elem->out_sg, elem->out_num, offset, &stat, sizeof(stat))
Amit Shahfa6111f2010-04-27 18:04:06 +0530279 == sizeof(stat)) {
Rusty Russell8609d2a2014-06-24 19:43:22 +0200280 uint16_t tag = virtio_tswap16(vdev, stat.tag);
281 uint64_t val = virtio_tswap64(vdev, stat.val);
Adam Litke625a5be2010-01-26 14:17:35 -0600282
283 offset += sizeof(stat);
284 if (tag < VIRTIO_BALLOON_S_NR)
285 s->stats[tag] = val;
286 }
287 s->stats_vq_offset = offset;
Luiz Capitulino7e6ccd92012-12-01 00:14:57 -0200288
289 if (qemu_gettimeofday(&tv) < 0) {
290 fprintf(stderr, "warning: %s: failed to get time of day\n", __func__);
291 goto out;
292 }
293
294 s->stats_last_update = tv.tv_sec;
295
296out:
297 if (balloon_stats_enabled(s)) {
298 balloon_stats_change_timer(s, s->stats_poll_interval);
299 }
Adam Litke625a5be2010-01-26 14:17:35 -0600300}
301
aliguoribd322082008-12-04 20:33:06 +0000302static void virtio_balloon_get_config(VirtIODevice *vdev, uint8_t *config_data)
303{
KONRAD Fredericc96cace2013-03-27 10:49:14 +0100304 VirtIOBalloon *dev = VIRTIO_BALLOON(vdev);
aliguoribd322082008-12-04 20:33:06 +0000305 struct virtio_balloon_config config;
306
307 config.num_pages = cpu_to_le32(dev->num_pages);
308 config.actual = cpu_to_le32(dev->actual);
309
zhanghailiang6adfdc52014-11-17 13:11:10 +0800310 trace_virtio_balloon_get_config(config.num_pages, config.actual);
Luiz Capitulinoe6baf612014-01-09 09:58:16 -0500311 memcpy(config_data, &config, sizeof(struct virtio_balloon_config));
aliguoribd322082008-12-04 20:33:06 +0000312}
313
Vladimir Sementsov-Ogievskiy2b75f842016-02-10 11:49:26 +0300314static int build_dimm_list(Object *obj, void *opaque)
315{
316 GSList **list = opaque;
317
318 if (object_dynamic_cast(obj, TYPE_PC_DIMM)) {
319 DeviceState *dev = DEVICE(obj);
320 if (dev->realized) { /* only realized DIMMs matter */
321 *list = g_slist_prepend(*list, dev);
322 }
323 }
324
325 object_child_foreach(obj, build_dimm_list, opaque);
326 return 0;
327}
328
Vladimir Sementsov-Ogievskiy39de9982016-02-10 11:49:22 +0300329static ram_addr_t get_current_ram_size(void)
330{
Vladimir Sementsov-Ogievskiye8dc06d2016-02-10 11:49:25 +0300331 GSList *list = NULL, *item;
Vladimir Sementsov-Ogievskiy39de9982016-02-10 11:49:22 +0300332 ram_addr_t size = ram_size;
333
Vladimir Sementsov-Ogievskiy2b75f842016-02-10 11:49:26 +0300334 build_dimm_list(qdev_get_machine(), &list);
Vladimir Sementsov-Ogievskiye8dc06d2016-02-10 11:49:25 +0300335 for (item = list; item; item = g_slist_next(item)) {
336 Object *obj = OBJECT(item->data);
Vladimir Sementsov-Ogievskiy2b75f842016-02-10 11:49:26 +0300337 if (!strcmp(object_get_typename(obj), TYPE_PC_DIMM)) {
338 size += object_property_get_int(obj, PC_DIMM_SIZE_PROP,
339 &error_abort);
340 }
Vladimir Sementsov-Ogievskiy39de9982016-02-10 11:49:22 +0300341 }
Vladimir Sementsov-Ogievskiye8dc06d2016-02-10 11:49:25 +0300342 g_slist_free(list);
Vladimir Sementsov-Ogievskiy39de9982016-02-10 11:49:22 +0300343
344 return size;
345}
346
aliguoribd322082008-12-04 20:33:06 +0000347static void virtio_balloon_set_config(VirtIODevice *vdev,
348 const uint8_t *config_data)
349{
KONRAD Fredericc96cace2013-03-27 10:49:14 +0100350 VirtIOBalloon *dev = VIRTIO_BALLOON(vdev);
aliguoribd322082008-12-04 20:33:06 +0000351 struct virtio_balloon_config config;
Daniel P. Berrange973603a2012-06-14 18:12:56 +0100352 uint32_t oldactual = dev->actual;
zhanghailiang463756d2014-11-17 13:11:09 +0800353 ram_addr_t vm_ram_size = get_current_ram_size();
354
Luiz Capitulinoe6baf612014-01-09 09:58:16 -0500355 memcpy(&config, config_data, sizeof(struct virtio_balloon_config));
Alexey Kardashevskiye54f1772011-04-07 13:02:04 +1000356 dev->actual = le32_to_cpu(config.actual);
Daniel P. Berrange973603a2012-06-14 18:12:56 +0100357 if (dev->actual != oldactual) {
zhanghailiang463756d2014-11-17 13:11:09 +0800358 qapi_event_send_balloon_change(vm_ram_size -
Wenchao Xiaaef9d312014-06-18 08:43:51 +0200359 ((ram_addr_t) dev->actual << VIRTIO_BALLOON_PFN_SHIFT),
360 &error_abort);
Daniel P. Berrange973603a2012-06-14 18:12:56 +0100361 }
zhanghailiang6adfdc52014-11-17 13:11:10 +0800362 trace_virtio_balloon_set_config(dev->actual, oldactual);
aliguoribd322082008-12-04 20:33:06 +0000363}
364
Jason Wang9d5b7312015-07-27 17:49:19 +0800365static uint64_t virtio_balloon_get_features(VirtIODevice *vdev, uint64_t f,
366 Error **errp)
aliguoribd322082008-12-04 20:33:06 +0000367{
Denis V. Luneve3816252015-06-15 13:52:52 +0300368 VirtIOBalloon *dev = VIRTIO_BALLOON(vdev);
369 f |= dev->host_features;
Cornelia Huck40de55a2015-06-04 12:34:32 +0200370 virtio_add_feature(&f, VIRTIO_BALLOON_F_STATS_VQ);
Michael S. Tsirkin81725392010-01-10 13:52:53 +0200371 return f;
aliguoribd322082008-12-04 20:33:06 +0000372}
373
Luiz Capitulino96637bc2011-10-21 11:41:37 -0200374static void virtio_balloon_stat(void *opaque, BalloonInfo *info)
Amit Shahdce911c2011-07-20 13:19:07 +0530375{
376 VirtIOBalloon *dev = opaque;
zhanghailiang463756d2014-11-17 13:11:09 +0800377 info->actual = get_current_ram_size() - ((uint64_t) dev->actual <<
378 VIRTIO_BALLOON_PFN_SHIFT);
Amit Shahdce911c2011-07-20 13:19:07 +0530379}
380
Amit Shah30fb2ca2011-07-20 13:30:56 +0530381static void virtio_balloon_to_target(void *opaque, ram_addr_t target)
aliguoribd322082008-12-04 20:33:06 +0000382{
KONRAD Fredericc96cace2013-03-27 10:49:14 +0100383 VirtIOBalloon *dev = VIRTIO_BALLOON(opaque);
384 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
zhanghailiang463756d2014-11-17 13:11:09 +0800385 ram_addr_t vm_ram_size = get_current_ram_size();
aliguoribd322082008-12-04 20:33:06 +0000386
zhanghailiang463756d2014-11-17 13:11:09 +0800387 if (target > vm_ram_size) {
388 target = vm_ram_size;
Amit Shahdce911c2011-07-20 13:19:07 +0530389 }
aliguoribd322082008-12-04 20:33:06 +0000390 if (target) {
zhanghailiang463756d2014-11-17 13:11:09 +0800391 dev->num_pages = (vm_ram_size - target) >> VIRTIO_BALLOON_PFN_SHIFT;
KONRAD Fredericc96cace2013-03-27 10:49:14 +0100392 virtio_notify_config(vdev);
aliguoribd322082008-12-04 20:33:06 +0000393 }
zhanghailiang6adfdc52014-11-17 13:11:10 +0800394 trace_virtio_balloon_to_target(target, dev->num_pages);
aliguoribd322082008-12-04 20:33:06 +0000395}
396
Dr. David Alan Gilbert019518a2016-10-27 18:36:37 +0100397static int virtio_balloon_post_load_device(void *opaque, int version_id)
Greg Kurz9ea25112014-06-24 19:20:08 +0200398{
Dr. David Alan Gilbert019518a2016-10-27 18:36:37 +0100399 VirtIOBalloon *s = VIRTIO_BALLOON(opaque);
Pavel Butsykinfecb48f2016-03-29 17:00:49 +0300400
401 if (balloon_stats_enabled(s)) {
402 balloon_stats_change_timer(s, s->stats_poll_interval);
403 }
aliguoribd322082008-12-04 20:33:06 +0000404 return 0;
405}
406
Dr. David Alan Gilbert019518a2016-10-27 18:36:37 +0100407static const VMStateDescription vmstate_virtio_balloon_device = {
408 .name = "virtio-balloon-device",
409 .version_id = 1,
410 .minimum_version_id = 1,
411 .post_load = virtio_balloon_post_load_device,
412 .fields = (VMStateField[]) {
413 VMSTATE_UINT32(num_pages, VirtIOBalloon),
414 VMSTATE_UINT32(actual, VirtIOBalloon),
415 VMSTATE_END_OF_LIST()
416 },
417};
418
Andreas Färber74def472013-07-30 02:51:37 +0200419static void virtio_balloon_device_realize(DeviceState *dev, Error **errp)
aliguoribd322082008-12-04 20:33:06 +0000420{
Andreas Färber74def472013-07-30 02:51:37 +0200421 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
Andreas Färbera546fb12013-07-30 05:33:58 +0200422 VirtIOBalloon *s = VIRTIO_BALLOON(dev);
Amit Shahf76f6652011-07-27 12:29:33 +0530423 int ret;
aliguoribd322082008-12-04 20:33:06 +0000424
Luiz Capitulinoe6baf612014-01-09 09:58:16 -0500425 virtio_init(vdev, "virtio-balloon", VIRTIO_ID_BALLOON,
426 sizeof(struct virtio_balloon_config));
aliguoribd322082008-12-04 20:33:06 +0000427
Amit Shahf76f6652011-07-27 12:29:33 +0530428 ret = qemu_add_balloon_handler(virtio_balloon_to_target,
429 virtio_balloon_stat, s);
KONRAD Frederic5c7d0962013-03-27 10:49:13 +0100430
KONRAD Frederic1ab461b2013-03-27 10:49:10 +0100431 if (ret < 0) {
Luiz Capitulino46abb812015-03-31 13:00:26 -0400432 error_setg(errp, "Only one balloon device is supported");
Andreas Färbera546fb12013-07-30 05:33:58 +0200433 virtio_cleanup(vdev);
Andreas Färber74def472013-07-30 02:51:37 +0200434 return;
KONRAD Frederic1ab461b2013-03-27 10:49:10 +0100435 }
Amit Shahf76f6652011-07-27 12:29:33 +0530436
KONRAD Frederic5c7d0962013-03-27 10:49:13 +0100437 s->ivq = virtio_add_queue(vdev, 128, virtio_balloon_handle_output);
438 s->dvq = virtio_add_queue(vdev, 128, virtio_balloon_handle_output);
439 s->svq = virtio_add_queue(vdev, 128, virtio_balloon_receive_stats);
aliguoribd322082008-12-04 20:33:06 +0000440
Ján Tomko38dbd482014-05-21 11:03:47 +0200441 reset_stats(s);
KONRAD Frederic1ab461b2013-03-27 10:49:10 +0100442}
443
Andreas Färber306ec6c2013-07-30 03:50:44 +0200444static void virtio_balloon_device_unrealize(DeviceState *dev, Error **errp)
KONRAD Frederic1ab461b2013-03-27 10:49:10 +0100445{
Andreas Färber306ec6c2013-07-30 03:50:44 +0200446 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
447 VirtIOBalloon *s = VIRTIO_BALLOON(dev);
KONRAD Frederic1ab461b2013-03-27 10:49:10 +0100448
449 balloon_stats_destroy_timer(s);
450 qemu_remove_balloon_handler(s);
KONRAD Frederic6a1a8cc2013-04-24 10:21:22 +0200451 virtio_cleanup(vdev);
KONRAD Frederic1ab461b2013-03-27 10:49:10 +0100452}
453
Ladi Prosek4eae2a62016-03-01 12:14:03 +0100454static void virtio_balloon_device_reset(VirtIODevice *vdev)
455{
456 VirtIOBalloon *s = VIRTIO_BALLOON(vdev);
457
458 if (s->stats_vq_elem != NULL) {
Ladi Prosek27e57ef2016-11-03 09:55:49 +0100459 virtqueue_unpop(s->svq, s->stats_vq_elem, 0);
Ladi Prosek4eae2a62016-03-01 12:14:03 +0100460 g_free(s->stats_vq_elem);
461 s->stats_vq_elem = NULL;
462 }
463}
464
Ladi Prosek4a1e48b2016-09-07 17:20:49 +0200465static void virtio_balloon_set_status(VirtIODevice *vdev, uint8_t status)
466{
467 VirtIOBalloon *s = VIRTIO_BALLOON(vdev);
468
469 if (!s->stats_vq_elem && vdev->vm_running &&
470 (status & VIRTIO_CONFIG_S_DRIVER_OK) && virtqueue_rewind(s->svq, 1)) {
471 /* poll stats queue for the element we have discarded when the VM
472 * was stopped */
473 virtio_balloon_receive_stats(vdev, s->svq);
474 }
475}
476
Shannon Zhao11900442015-05-11 17:34:05 +0800477static void virtio_balloon_instance_init(Object *obj)
478{
479 VirtIOBalloon *s = VIRTIO_BALLOON(obj);
480
481 object_property_add(obj, "guest-stats", "guest statistics",
482 balloon_stats_get_all, NULL, NULL, s, NULL);
483
484 object_property_add(obj, "guest-stats-polling-interval", "int",
485 balloon_stats_get_poll_interval,
486 balloon_stats_set_poll_interval,
487 NULL, s, NULL);
488}
489
Halil Pasicc5dc16b2016-10-06 14:55:47 +0200490static const VMStateDescription vmstate_virtio_balloon = {
491 .name = "virtio-balloon",
492 .minimum_version_id = 1,
493 .version_id = 1,
494 .fields = (VMStateField[]) {
495 VMSTATE_VIRTIO_DEVICE,
496 VMSTATE_END_OF_LIST()
497 },
498};
Dr. David Alan Gilbert7f1ca9b2016-07-14 18:22:49 +0100499
KONRAD Frederic1ab461b2013-03-27 10:49:10 +0100500static Property virtio_balloon_properties[] = {
Denis V. Luneve3816252015-06-15 13:52:52 +0300501 DEFINE_PROP_BIT("deflate-on-oom", VirtIOBalloon, host_features,
502 VIRTIO_BALLOON_F_DEFLATE_ON_OOM, false),
KONRAD Frederic1ab461b2013-03-27 10:49:10 +0100503 DEFINE_PROP_END_OF_LIST(),
504};
505
506static void virtio_balloon_class_init(ObjectClass *klass, void *data)
507{
508 DeviceClass *dc = DEVICE_CLASS(klass);
509 VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
Andreas Färber74def472013-07-30 02:51:37 +0200510
KONRAD Frederic1ab461b2013-03-27 10:49:10 +0100511 dc->props = virtio_balloon_properties;
Dr. David Alan Gilbert7f1ca9b2016-07-14 18:22:49 +0100512 dc->vmsd = &vmstate_virtio_balloon;
Marcel Apfelbaum125ee0e2013-07-29 17:17:45 +0300513 set_bit(DEVICE_CATEGORY_MISC, dc->categories);
Andreas Färber74def472013-07-30 02:51:37 +0200514 vdc->realize = virtio_balloon_device_realize;
Andreas Färber306ec6c2013-07-30 03:50:44 +0200515 vdc->unrealize = virtio_balloon_device_unrealize;
Ladi Prosek4eae2a62016-03-01 12:14:03 +0100516 vdc->reset = virtio_balloon_device_reset;
KONRAD Frederic1ab461b2013-03-27 10:49:10 +0100517 vdc->get_config = virtio_balloon_get_config;
518 vdc->set_config = virtio_balloon_set_config;
519 vdc->get_features = virtio_balloon_get_features;
Ladi Prosek4a1e48b2016-09-07 17:20:49 +0200520 vdc->set_status = virtio_balloon_set_status;
Dr. David Alan Gilbert019518a2016-10-27 18:36:37 +0100521 vdc->vmsd = &vmstate_virtio_balloon_device;
KONRAD Frederic1ab461b2013-03-27 10:49:10 +0100522}
523
524static const TypeInfo virtio_balloon_info = {
525 .name = TYPE_VIRTIO_BALLOON,
526 .parent = TYPE_VIRTIO_DEVICE,
527 .instance_size = sizeof(VirtIOBalloon),
Shannon Zhao11900442015-05-11 17:34:05 +0800528 .instance_init = virtio_balloon_instance_init,
KONRAD Frederic1ab461b2013-03-27 10:49:10 +0100529 .class_init = virtio_balloon_class_init,
530};
531
532static void virtio_register_types(void)
533{
534 type_register_static(&virtio_balloon_info);
535}
536
537type_init(virtio_register_types)