2 * Virtio Balloon Device
4 * Copyright IBM, Corp. 2008
5 * Copyright (C) 2011 Red Hat, Inc.
6 * Copyright (C) 2011 Amit Shah <amit.shah@redhat.com>
9 * Anthony Liguori <aliguori@us.ibm.com>
11 * This work is licensed under the terms of the GNU GPL, version 2. See
12 * the COPYING file in the top-level directory.
16 #include "qemu/osdep.h"
18 #include "qemu/timer.h"
19 #include "qemu-common.h"
20 #include "hw/virtio/virtio.h"
21 #include "hw/i386/pc.h"
22 #include "sysemu/balloon.h"
23 #include "hw/virtio/virtio-balloon.h"
24 #include "sysemu/kvm.h"
25 #include "exec/address-spaces.h"
26 #include "qapi/visitor.h"
27 #include "qapi-event.h"
30 #include "hw/virtio/virtio-bus.h"
31 #include "hw/virtio/virtio-access.h"
33 #define BALLOON_PAGE_SIZE (1 << VIRTIO_BALLOON_PFN_SHIFT)
35 static void balloon_page(void *addr
, int deflate
)
37 if (!qemu_balloon_is_inhibited() && (!kvm_enabled() ||
38 kvm_has_sync_mmu())) {
39 qemu_madvise(addr
, BALLOON_PAGE_SIZE
,
40 deflate
? QEMU_MADV_WILLNEED
: QEMU_MADV_DONTNEED
);
44 static 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",
51 [VIRTIO_BALLOON_S_AVAIL
] = "stat-available-memory",
52 [VIRTIO_BALLOON_S_NR
] = NULL
56 * reset_stats - Mark all items in the stats array as unset
58 * 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
60 * stale values stick around in case the guest reports a subset of the supported
63 static inline void reset_stats(VirtIOBalloon
*dev
)
66 for (i
= 0; i
< VIRTIO_BALLOON_S_NR
; dev
->stats
[i
++] = -1);
69 static bool balloon_stats_supported(const VirtIOBalloon
*s
)
71 VirtIODevice
*vdev
= VIRTIO_DEVICE(s
);
72 return virtio_vdev_has_feature(vdev
, VIRTIO_BALLOON_F_STATS_VQ
);
75 static bool balloon_stats_enabled(const VirtIOBalloon
*s
)
77 return s
->stats_poll_interval
> 0;
80 static void balloon_stats_destroy_timer(VirtIOBalloon
*s
)
82 if (balloon_stats_enabled(s
)) {
83 timer_del(s
->stats_timer
);
84 timer_free(s
->stats_timer
);
85 s
->stats_timer
= NULL
;
86 s
->stats_poll_interval
= 0;
90 static void balloon_stats_change_timer(VirtIOBalloon
*s
, int64_t secs
)
92 timer_mod(s
->stats_timer
, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
) + secs
* 1000);
95 static void balloon_stats_poll_cb(void *opaque
)
97 VirtIOBalloon
*s
= opaque
;
98 VirtIODevice
*vdev
= VIRTIO_DEVICE(s
);
100 if (s
->stats_vq_elem
== NULL
|| !balloon_stats_supported(s
)) {
102 balloon_stats_change_timer(s
, s
->stats_poll_interval
);
106 virtqueue_push(s
->svq
, s
->stats_vq_elem
, s
->stats_vq_offset
);
107 virtio_notify(vdev
, s
->svq
);
108 g_free(s
->stats_vq_elem
);
109 s
->stats_vq_elem
= NULL
;
112 static void balloon_stats_get_all(Object
*obj
, Visitor
*v
, const char *name
,
113 void *opaque
, Error
**errp
)
116 VirtIOBalloon
*s
= opaque
;
119 visit_start_struct(v
, name
, NULL
, 0, &err
);
123 visit_type_int(v
, "last-update", &s
->stats_last_update
, &err
);
128 visit_start_struct(v
, "stats", NULL
, 0, &err
);
132 for (i
= 0; i
< VIRTIO_BALLOON_S_NR
; i
++) {
133 visit_type_uint64(v
, balloon_stat_names
[i
], &s
->stats
[i
], &err
);
138 visit_check_struct(v
, &err
);
140 visit_end_struct(v
, NULL
);
143 visit_check_struct(v
, &err
);
146 visit_end_struct(v
, NULL
);
148 error_propagate(errp
, err
);
151 static void balloon_stats_get_poll_interval(Object
*obj
, Visitor
*v
,
152 const char *name
, void *opaque
,
155 VirtIOBalloon
*s
= opaque
;
156 visit_type_int(v
, name
, &s
->stats_poll_interval
, errp
);
159 static void balloon_stats_set_poll_interval(Object
*obj
, Visitor
*v
,
160 const char *name
, void *opaque
,
163 VirtIOBalloon
*s
= opaque
;
164 Error
*local_err
= NULL
;
167 visit_type_int(v
, name
, &value
, &local_err
);
169 error_propagate(errp
, local_err
);
174 error_setg(errp
, "timer value must be greater than zero");
178 if (value
> UINT32_MAX
) {
179 error_setg(errp
, "timer value is too big");
183 if (value
== s
->stats_poll_interval
) {
188 /* timer=0 disables the timer */
189 balloon_stats_destroy_timer(s
);
193 if (balloon_stats_enabled(s
)) {
194 /* timer interval change */
195 s
->stats_poll_interval
= value
;
196 balloon_stats_change_timer(s
, value
);
200 /* create a new timer */
201 g_assert(s
->stats_timer
== NULL
);
202 s
->stats_timer
= timer_new_ms(QEMU_CLOCK_VIRTUAL
, balloon_stats_poll_cb
, s
);
203 s
->stats_poll_interval
= value
;
204 balloon_stats_change_timer(s
, 0);
207 static void virtio_balloon_handle_output(VirtIODevice
*vdev
, VirtQueue
*vq
)
209 VirtIOBalloon
*s
= VIRTIO_BALLOON(vdev
);
210 VirtQueueElement
*elem
;
211 MemoryRegionSection section
;
216 elem
= virtqueue_pop(vq
, sizeof(VirtQueueElement
));
221 while (iov_to_buf(elem
->out_sg
, elem
->out_num
, offset
, &pfn
, 4) == 4) {
224 int p
= virtio_ldl_p(vdev
, &pfn
);
226 pa
= (ram_addr_t
) p
<< VIRTIO_BALLOON_PFN_SHIFT
;
229 /* FIXME: remove get_system_memory(), but how? */
230 section
= memory_region_find(get_system_memory(), pa
, 1);
231 if (!int128_nz(section
.size
) || !memory_region_is_ram(section
.mr
))
234 trace_virtio_balloon_handle_output(memory_region_name(section
.mr
),
236 /* Using memory_region_get_ram_ptr is bending the rules a bit, but
237 should be OK because we only want a single page. */
238 addr
= section
.offset_within_region
;
239 balloon_page(memory_region_get_ram_ptr(section
.mr
) + addr
,
241 memory_region_unref(section
.mr
);
244 virtqueue_push(vq
, elem
, offset
);
245 virtio_notify(vdev
, vq
);
250 static void virtio_balloon_receive_stats(VirtIODevice
*vdev
, VirtQueue
*vq
)
252 VirtIOBalloon
*s
= VIRTIO_BALLOON(vdev
);
253 VirtQueueElement
*elem
;
254 VirtIOBalloonStat stat
;
258 elem
= virtqueue_pop(vq
, sizeof(VirtQueueElement
));
263 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
);
270 s
->stats_vq_elem
= elem
;
272 /* 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).
278 while (iov_to_buf(elem
->out_sg
, elem
->out_num
, offset
, &stat
, sizeof(stat
))
280 uint16_t tag
= virtio_tswap16(vdev
, stat
.tag
);
281 uint64_t val
= virtio_tswap64(vdev
, stat
.val
);
283 offset
+= sizeof(stat
);
284 if (tag
< VIRTIO_BALLOON_S_NR
)
287 s
->stats_vq_offset
= offset
;
289 if (qemu_gettimeofday(&tv
) < 0) {
290 fprintf(stderr
, "warning: %s: failed to get time of day\n", __func__
);
294 s
->stats_last_update
= tv
.tv_sec
;
297 if (balloon_stats_enabled(s
)) {
298 balloon_stats_change_timer(s
, s
->stats_poll_interval
);
302 static void virtio_balloon_get_config(VirtIODevice
*vdev
, uint8_t *config_data
)
304 VirtIOBalloon
*dev
= VIRTIO_BALLOON(vdev
);
305 struct virtio_balloon_config config
;
307 config
.num_pages
= cpu_to_le32(dev
->num_pages
);
308 config
.actual
= cpu_to_le32(dev
->actual
);
310 trace_virtio_balloon_get_config(config
.num_pages
, config
.actual
);
311 memcpy(config_data
, &config
, sizeof(struct virtio_balloon_config
));
314 static int build_dimm_list(Object
*obj
, void *opaque
)
316 GSList
**list
= opaque
;
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
);
325 object_child_foreach(obj
, build_dimm_list
, opaque
);
329 static ram_addr_t
get_current_ram_size(void)
331 GSList
*list
= NULL
, *item
;
332 ram_addr_t size
= ram_size
;
334 build_dimm_list(qdev_get_machine(), &list
);
335 for (item
= list
; item
; item
= g_slist_next(item
)) {
336 Object
*obj
= OBJECT(item
->data
);
337 if (!strcmp(object_get_typename(obj
), TYPE_PC_DIMM
)) {
338 size
+= object_property_get_int(obj
, PC_DIMM_SIZE_PROP
,
347 static void virtio_balloon_set_config(VirtIODevice
*vdev
,
348 const uint8_t *config_data
)
350 VirtIOBalloon
*dev
= VIRTIO_BALLOON(vdev
);
351 struct virtio_balloon_config config
;
352 uint32_t oldactual
= dev
->actual
;
353 ram_addr_t vm_ram_size
= get_current_ram_size();
355 memcpy(&config
, config_data
, sizeof(struct virtio_balloon_config
));
356 dev
->actual
= le32_to_cpu(config
.actual
);
357 if (dev
->actual
!= oldactual
) {
358 qapi_event_send_balloon_change(vm_ram_size
-
359 ((ram_addr_t
) dev
->actual
<< VIRTIO_BALLOON_PFN_SHIFT
),
362 trace_virtio_balloon_set_config(dev
->actual
, oldactual
);
365 static uint64_t virtio_balloon_get_features(VirtIODevice
*vdev
, uint64_t f
,
368 VirtIOBalloon
*dev
= VIRTIO_BALLOON(vdev
);
369 f
|= dev
->host_features
;
370 virtio_add_feature(&f
, VIRTIO_BALLOON_F_STATS_VQ
);
374 static void virtio_balloon_stat(void *opaque
, BalloonInfo
*info
)
376 VirtIOBalloon
*dev
= opaque
;
377 info
->actual
= get_current_ram_size() - ((uint64_t) dev
->actual
<<
378 VIRTIO_BALLOON_PFN_SHIFT
);
381 static void virtio_balloon_to_target(void *opaque
, ram_addr_t target
)
383 VirtIOBalloon
*dev
= VIRTIO_BALLOON(opaque
);
384 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
385 ram_addr_t vm_ram_size
= get_current_ram_size();
387 if (target
> vm_ram_size
) {
388 target
= vm_ram_size
;
391 dev
->num_pages
= (vm_ram_size
- target
) >> VIRTIO_BALLOON_PFN_SHIFT
;
392 virtio_notify_config(vdev
);
394 trace_virtio_balloon_to_target(target
, dev
->num_pages
);
397 static int virtio_balloon_post_load_device(void *opaque
, int version_id
)
399 VirtIOBalloon
*s
= VIRTIO_BALLOON(opaque
);
401 if (balloon_stats_enabled(s
)) {
402 balloon_stats_change_timer(s
, s
->stats_poll_interval
);
407 static const VMStateDescription vmstate_virtio_balloon_device
= {
408 .name
= "virtio-balloon-device",
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()
419 static void virtio_balloon_device_realize(DeviceState
*dev
, Error
**errp
)
421 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
422 VirtIOBalloon
*s
= VIRTIO_BALLOON(dev
);
425 virtio_init(vdev
, "virtio-balloon", VIRTIO_ID_BALLOON
,
426 sizeof(struct virtio_balloon_config
));
428 ret
= qemu_add_balloon_handler(virtio_balloon_to_target
,
429 virtio_balloon_stat
, s
);
432 error_setg(errp
, "Only one balloon device is supported");
433 virtio_cleanup(vdev
);
437 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
);
444 static void virtio_balloon_device_unrealize(DeviceState
*dev
, Error
**errp
)
446 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
447 VirtIOBalloon
*s
= VIRTIO_BALLOON(dev
);
449 balloon_stats_destroy_timer(s
);
450 qemu_remove_balloon_handler(s
);
451 virtio_cleanup(vdev
);
454 static void virtio_balloon_device_reset(VirtIODevice
*vdev
)
456 VirtIOBalloon
*s
= VIRTIO_BALLOON(vdev
);
458 if (s
->stats_vq_elem
!= NULL
) {
459 virtqueue_unpop(s
->svq
, s
->stats_vq_elem
, 0);
460 g_free(s
->stats_vq_elem
);
461 s
->stats_vq_elem
= NULL
;
465 static void virtio_balloon_set_status(VirtIODevice
*vdev
, uint8_t status
)
467 VirtIOBalloon
*s
= VIRTIO_BALLOON(vdev
);
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
473 virtio_balloon_receive_stats(vdev
, s
->svq
);
477 static void virtio_balloon_instance_init(Object
*obj
)
479 VirtIOBalloon
*s
= VIRTIO_BALLOON(obj
);
481 object_property_add(obj
, "guest-stats", "guest statistics",
482 balloon_stats_get_all
, NULL
, NULL
, s
, NULL
);
484 object_property_add(obj
, "guest-stats-polling-interval", "int",
485 balloon_stats_get_poll_interval
,
486 balloon_stats_set_poll_interval
,
490 static const VMStateDescription vmstate_virtio_balloon
= {
491 .name
= "virtio-balloon",
492 .minimum_version_id
= 1,
494 .fields
= (VMStateField
[]) {
495 VMSTATE_VIRTIO_DEVICE
,
496 VMSTATE_END_OF_LIST()
500 static Property virtio_balloon_properties
[] = {
501 DEFINE_PROP_BIT("deflate-on-oom", VirtIOBalloon
, host_features
,
502 VIRTIO_BALLOON_F_DEFLATE_ON_OOM
, false),
503 DEFINE_PROP_END_OF_LIST(),
506 static void virtio_balloon_class_init(ObjectClass
*klass
, void *data
)
508 DeviceClass
*dc
= DEVICE_CLASS(klass
);
509 VirtioDeviceClass
*vdc
= VIRTIO_DEVICE_CLASS(klass
);
511 dc
->props
= virtio_balloon_properties
;
512 dc
->vmsd
= &vmstate_virtio_balloon
;
513 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
514 vdc
->realize
= virtio_balloon_device_realize
;
515 vdc
->unrealize
= virtio_balloon_device_unrealize
;
516 vdc
->reset
= virtio_balloon_device_reset
;
517 vdc
->get_config
= virtio_balloon_get_config
;
518 vdc
->set_config
= virtio_balloon_set_config
;
519 vdc
->get_features
= virtio_balloon_get_features
;
520 vdc
->set_status
= virtio_balloon_set_status
;
521 vdc
->vmsd
= &vmstate_virtio_balloon_device
;
524 static const TypeInfo virtio_balloon_info
= {
525 .name
= TYPE_VIRTIO_BALLOON
,
526 .parent
= TYPE_VIRTIO_DEVICE
,
527 .instance_size
= sizeof(VirtIOBalloon
),
528 .instance_init
= virtio_balloon_instance_init
,
529 .class_init
= virtio_balloon_class_init
,
532 static void virtio_register_types(void)
534 type_register_static(&virtio_balloon_info
);
537 type_init(virtio_register_types
)