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/module.h"
19 #include "qemu/timer.h"
20 #include "hw/virtio/virtio.h"
21 #include "hw/mem/pc-dimm.h"
22 #include "hw/qdev-properties.h"
23 #include "hw/boards.h"
24 #include "sysemu/balloon.h"
25 #include "hw/virtio/virtio-balloon.h"
26 #include "exec/address-spaces.h"
27 #include "qapi/error.h"
28 #include "qapi/qapi-events-machine.h"
29 #include "qapi/visitor.h"
31 #include "qemu/error-report.h"
32 #include "migration/misc.h"
33 #include "migration/migration.h"
35 #include "hw/virtio/virtio-bus.h"
36 #include "hw/virtio/virtio-access.h"
38 #define BALLOON_PAGE_SIZE (1 << VIRTIO_BALLOON_PFN_SHIFT)
40 typedef struct PartiallyBalloonedPage
{
42 unsigned long *bitmap
;
43 } PartiallyBalloonedPage
;
45 static void virtio_balloon_pbp_free(PartiallyBalloonedPage
*pbp
)
54 static void virtio_balloon_pbp_alloc(PartiallyBalloonedPage
*pbp
,
58 pbp
->base_gpa
= base_gpa
;
59 pbp
->bitmap
= bitmap_new(subpages
);
62 static bool virtio_balloon_pbp_matches(PartiallyBalloonedPage
*pbp
,
65 return pbp
->base_gpa
== base_gpa
;
68 static bool virtio_balloon_inhibited(void)
71 * Postcopy cannot deal with concurrent discards,
72 * so it's special, as well as background snapshots.
74 return ram_block_discard_is_disabled() || migration_in_incoming_postcopy() ||
75 migration_in_bg_snapshot();
78 static void balloon_inflate_page(VirtIOBalloon
*balloon
,
79 MemoryRegion
*mr
, hwaddr mr_offset
,
80 PartiallyBalloonedPage
*pbp
)
82 void *addr
= memory_region_get_ram_ptr(mr
) + mr_offset
;
83 ram_addr_t rb_offset
, rb_aligned_offset
, base_gpa
;
88 /* XXX is there a better way to get to the RAMBlock than via a
90 rb
= qemu_ram_block_from_host(addr
, false, &rb_offset
);
91 rb_page_size
= qemu_ram_pagesize(rb
);
93 if (rb_page_size
== BALLOON_PAGE_SIZE
) {
96 ram_block_discard_range(rb
, rb_offset
, rb_page_size
);
97 /* We ignore errors from ram_block_discard_range(), because it
98 * has already reported them, and failing to discard a balloon
99 * page is not fatal */
105 * We've put a piece of a larger host page into the balloon - we
106 * need to keep track until we have a whole host page to
110 "Balloon used with backing page size > 4kiB, this may not be reliable");
112 rb_aligned_offset
= QEMU_ALIGN_DOWN(rb_offset
, rb_page_size
);
113 subpages
= rb_page_size
/ BALLOON_PAGE_SIZE
;
114 base_gpa
= memory_region_get_ram_addr(mr
) + mr_offset
-
115 (rb_offset
- rb_aligned_offset
);
117 if (pbp
->bitmap
&& !virtio_balloon_pbp_matches(pbp
, base_gpa
)) {
118 /* We've partially ballooned part of a host page, but now
119 * we're trying to balloon part of a different one. Too hard,
120 * give up on the old partial page */
121 virtio_balloon_pbp_free(pbp
);
125 virtio_balloon_pbp_alloc(pbp
, base_gpa
, subpages
);
128 set_bit((rb_offset
- rb_aligned_offset
) / BALLOON_PAGE_SIZE
,
131 if (bitmap_full(pbp
->bitmap
, subpages
)) {
132 /* We've accumulated a full host page, we can actually discard
135 ram_block_discard_range(rb
, rb_aligned_offset
, rb_page_size
);
136 /* We ignore errors from ram_block_discard_range(), because it
137 * has already reported them, and failing to discard a balloon
138 * page is not fatal */
139 virtio_balloon_pbp_free(pbp
);
143 static void balloon_deflate_page(VirtIOBalloon
*balloon
,
144 MemoryRegion
*mr
, hwaddr mr_offset
)
146 void *addr
= memory_region_get_ram_ptr(mr
) + mr_offset
;
147 ram_addr_t rb_offset
;
153 /* XXX is there a better way to get to the RAMBlock than via a
155 rb
= qemu_ram_block_from_host(addr
, false, &rb_offset
);
156 rb_page_size
= qemu_ram_pagesize(rb
);
158 host_addr
= (void *)((uintptr_t)addr
& ~(rb_page_size
- 1));
160 /* When a page is deflated, we hint the whole host page it lives
161 * on, since we can't do anything smaller */
162 ret
= qemu_madvise(host_addr
, rb_page_size
, QEMU_MADV_WILLNEED
);
164 warn_report("Couldn't MADV_WILLNEED on balloon deflate: %s",
166 /* Otherwise ignore, failing to page hint shouldn't be fatal */
170 static const char *balloon_stat_names
[] = {
171 [VIRTIO_BALLOON_S_SWAP_IN
] = "stat-swap-in",
172 [VIRTIO_BALLOON_S_SWAP_OUT
] = "stat-swap-out",
173 [VIRTIO_BALLOON_S_MAJFLT
] = "stat-major-faults",
174 [VIRTIO_BALLOON_S_MINFLT
] = "stat-minor-faults",
175 [VIRTIO_BALLOON_S_MEMFREE
] = "stat-free-memory",
176 [VIRTIO_BALLOON_S_MEMTOT
] = "stat-total-memory",
177 [VIRTIO_BALLOON_S_AVAIL
] = "stat-available-memory",
178 [VIRTIO_BALLOON_S_CACHES
] = "stat-disk-caches",
179 [VIRTIO_BALLOON_S_HTLB_PGALLOC
] = "stat-htlb-pgalloc",
180 [VIRTIO_BALLOON_S_HTLB_PGFAIL
] = "stat-htlb-pgfail",
181 [VIRTIO_BALLOON_S_NR
] = NULL
185 * reset_stats - Mark all items in the stats array as unset
187 * This function needs to be called at device initialization and before
188 * updating to a set of newly-generated stats. This will ensure that no
189 * stale values stick around in case the guest reports a subset of the supported
192 static inline void reset_stats(VirtIOBalloon
*dev
)
195 for (i
= 0; i
< VIRTIO_BALLOON_S_NR
; dev
->stats
[i
++] = -1);
198 static bool balloon_stats_supported(const VirtIOBalloon
*s
)
200 VirtIODevice
*vdev
= VIRTIO_DEVICE(s
);
201 return virtio_vdev_has_feature(vdev
, VIRTIO_BALLOON_F_STATS_VQ
);
204 static bool balloon_stats_enabled(const VirtIOBalloon
*s
)
206 return s
->stats_poll_interval
> 0;
209 static void balloon_stats_destroy_timer(VirtIOBalloon
*s
)
211 if (balloon_stats_enabled(s
)) {
212 timer_free(s
->stats_timer
);
213 s
->stats_timer
= NULL
;
214 s
->stats_poll_interval
= 0;
218 static void balloon_stats_change_timer(VirtIOBalloon
*s
, int64_t secs
)
220 timer_mod(s
->stats_timer
, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
) + secs
* 1000);
223 static void balloon_stats_poll_cb(void *opaque
)
225 VirtIOBalloon
*s
= opaque
;
226 VirtIODevice
*vdev
= VIRTIO_DEVICE(s
);
228 if (s
->stats_vq_elem
== NULL
|| !balloon_stats_supported(s
)) {
230 balloon_stats_change_timer(s
, s
->stats_poll_interval
);
234 virtqueue_push(s
->svq
, s
->stats_vq_elem
, 0);
235 virtio_notify(vdev
, s
->svq
);
236 g_free(s
->stats_vq_elem
);
237 s
->stats_vq_elem
= NULL
;
240 static void balloon_stats_get_all(Object
*obj
, Visitor
*v
, const char *name
,
241 void *opaque
, Error
**errp
)
244 VirtIOBalloon
*s
= opaque
;
247 if (!visit_start_struct(v
, name
, NULL
, 0, &err
)) {
250 if (!visit_type_int(v
, "last-update", &s
->stats_last_update
, &err
)) {
254 if (!visit_start_struct(v
, "stats", NULL
, 0, &err
)) {
257 for (i
= 0; i
< VIRTIO_BALLOON_S_NR
; i
++) {
258 if (!visit_type_uint64(v
, balloon_stat_names
[i
], &s
->stats
[i
], &err
)) {
262 visit_check_struct(v
, &err
);
264 visit_end_struct(v
, NULL
);
267 visit_check_struct(v
, &err
);
270 visit_end_struct(v
, NULL
);
272 error_propagate(errp
, err
);
275 static void balloon_stats_get_poll_interval(Object
*obj
, Visitor
*v
,
276 const char *name
, void *opaque
,
279 VirtIOBalloon
*s
= opaque
;
280 visit_type_int(v
, name
, &s
->stats_poll_interval
, errp
);
283 static void balloon_stats_set_poll_interval(Object
*obj
, Visitor
*v
,
284 const char *name
, void *opaque
,
287 VirtIOBalloon
*s
= opaque
;
290 if (!visit_type_int(v
, name
, &value
, errp
)) {
295 error_setg(errp
, "timer value must be greater than zero");
299 if (value
> UINT32_MAX
) {
300 error_setg(errp
, "timer value is too big");
304 if (value
== s
->stats_poll_interval
) {
309 /* timer=0 disables the timer */
310 balloon_stats_destroy_timer(s
);
314 if (balloon_stats_enabled(s
)) {
315 /* timer interval change */
316 s
->stats_poll_interval
= value
;
317 balloon_stats_change_timer(s
, value
);
321 /* create a new timer */
322 g_assert(s
->stats_timer
== NULL
);
323 s
->stats_timer
= timer_new_ms(QEMU_CLOCK_VIRTUAL
, balloon_stats_poll_cb
, s
);
324 s
->stats_poll_interval
= value
;
325 balloon_stats_change_timer(s
, 0);
328 static void virtio_balloon_handle_report(VirtIODevice
*vdev
, VirtQueue
*vq
)
330 VirtIOBalloon
*dev
= VIRTIO_BALLOON(vdev
);
331 VirtQueueElement
*elem
;
333 while ((elem
= virtqueue_pop(vq
, sizeof(VirtQueueElement
)))) {
337 * When we discard the page it has the effect of removing the page
338 * from the hypervisor itself and causing it to be zeroed when it
339 * is returned to us. So we must not discard the page if it is
340 * accessible by another device or process, or if the guest is
341 * expecting it to retain a non-zero value.
343 if (virtio_balloon_inhibited() || dev
->poison_val
) {
347 for (i
= 0; i
< elem
->in_num
; i
++) {
348 void *addr
= elem
->in_sg
[i
].iov_base
;
349 size_t size
= elem
->in_sg
[i
].iov_len
;
350 ram_addr_t ram_offset
;
354 * There is no need to check the memory section to see if
355 * it is ram/readonly/romd like there is for handle_output
356 * below. If the region is not meant to be written to then
357 * address_space_map will have allocated a bounce buffer
358 * and it will be freed in address_space_unmap and trigger
359 * and unassigned_mem_write before failing to copy over the
360 * buffer. If more than one bad descriptor is provided it
361 * will return NULL after the first bounce buffer and fail
362 * to map any resources.
364 rb
= qemu_ram_block_from_host(addr
, false, &ram_offset
);
366 trace_virtio_balloon_bad_addr(elem
->in_addr
[i
]);
371 * For now we will simply ignore unaligned memory regions, or
372 * regions that overrun the end of the RAMBlock.
374 if (!QEMU_IS_ALIGNED(ram_offset
| size
, qemu_ram_pagesize(rb
)) ||
375 (ram_offset
+ size
) > qemu_ram_get_used_length(rb
)) {
379 ram_block_discard_range(rb
, ram_offset
, size
);
383 virtqueue_push(vq
, elem
, 0);
384 virtio_notify(vdev
, vq
);
389 static void virtio_balloon_handle_output(VirtIODevice
*vdev
, VirtQueue
*vq
)
391 VirtIOBalloon
*s
= VIRTIO_BALLOON(vdev
);
392 VirtQueueElement
*elem
;
393 MemoryRegionSection section
;
396 PartiallyBalloonedPage pbp
= {};
400 elem
= virtqueue_pop(vq
, sizeof(VirtQueueElement
));
405 while (iov_to_buf(elem
->out_sg
, elem
->out_num
, offset
, &pfn
, 4) == 4) {
406 unsigned int p
= virtio_ldl_p(vdev
, &pfn
);
409 pa
= (hwaddr
) p
<< VIRTIO_BALLOON_PFN_SHIFT
;
412 section
= memory_region_find(get_system_memory(), pa
,
415 trace_virtio_balloon_bad_addr(pa
);
418 if (!memory_region_is_ram(section
.mr
) ||
419 memory_region_is_rom(section
.mr
) ||
420 memory_region_is_romd(section
.mr
)) {
421 trace_virtio_balloon_bad_addr(pa
);
422 memory_region_unref(section
.mr
);
426 trace_virtio_balloon_handle_output(memory_region_name(section
.mr
),
428 if (!virtio_balloon_inhibited()) {
430 balloon_inflate_page(s
, section
.mr
,
431 section
.offset_within_region
, &pbp
);
432 } else if (vq
== s
->dvq
) {
433 balloon_deflate_page(s
, section
.mr
, section
.offset_within_region
);
435 g_assert_not_reached();
438 memory_region_unref(section
.mr
);
441 virtqueue_push(vq
, elem
, 0);
442 virtio_notify(vdev
, vq
);
444 virtio_balloon_pbp_free(&pbp
);
448 static void virtio_balloon_receive_stats(VirtIODevice
*vdev
, VirtQueue
*vq
)
450 VirtIOBalloon
*s
= VIRTIO_BALLOON(vdev
);
451 VirtQueueElement
*elem
;
452 VirtIOBalloonStat stat
;
456 elem
= virtqueue_pop(vq
, sizeof(VirtQueueElement
));
461 if (s
->stats_vq_elem
!= NULL
) {
462 /* This should never happen if the driver follows the spec. */
463 virtqueue_push(vq
, s
->stats_vq_elem
, 0);
464 virtio_notify(vdev
, vq
);
465 g_free(s
->stats_vq_elem
);
468 s
->stats_vq_elem
= elem
;
470 /* Initialize the stats to get rid of any stale values. This is only
471 * needed to handle the case where a guest supports fewer stats than it
472 * used to (ie. it has booted into an old kernel).
476 while (iov_to_buf(elem
->out_sg
, elem
->out_num
, offset
, &stat
, sizeof(stat
))
478 uint16_t tag
= virtio_tswap16(vdev
, stat
.tag
);
479 uint64_t val
= virtio_tswap64(vdev
, stat
.val
);
481 offset
+= sizeof(stat
);
482 if (tag
< VIRTIO_BALLOON_S_NR
)
485 s
->stats_vq_offset
= offset
;
487 if (qemu_gettimeofday(&tv
) < 0) {
488 warn_report("%s: failed to get time of day", __func__
);
492 s
->stats_last_update
= tv
.tv_sec
;
495 if (balloon_stats_enabled(s
)) {
496 balloon_stats_change_timer(s
, s
->stats_poll_interval
);
500 static void virtio_balloon_handle_free_page_vq(VirtIODevice
*vdev
,
503 VirtIOBalloon
*s
= VIRTIO_BALLOON(vdev
);
504 qemu_bh_schedule(s
->free_page_bh
);
507 static bool get_free_page_hints(VirtIOBalloon
*dev
)
509 VirtQueueElement
*elem
;
510 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
511 VirtQueue
*vq
= dev
->free_page_vq
;
515 while (dev
->block_iothread
) {
516 qemu_cond_wait(&dev
->free_page_cond
, &dev
->free_page_lock
);
519 elem
= virtqueue_pop(vq
, sizeof(VirtQueueElement
));
526 size_t size
= iov_to_buf(elem
->out_sg
, elem
->out_num
, 0,
529 virtio_tswap32s(vdev
, &id
);
530 if (unlikely(size
!= sizeof(id
))) {
531 virtio_error(vdev
, "received an incorrect cmd id");
535 if (dev
->free_page_hint_status
== FREE_PAGE_HINT_S_REQUESTED
&&
536 id
== dev
->free_page_hint_cmd_id
) {
537 dev
->free_page_hint_status
= FREE_PAGE_HINT_S_START
;
538 } else if (dev
->free_page_hint_status
== FREE_PAGE_HINT_S_START
) {
540 * Stop the optimization only when it has started. This
541 * avoids a stale stop sign for the previous command.
543 dev
->free_page_hint_status
= FREE_PAGE_HINT_S_STOP
;
547 if (elem
->in_num
&& dev
->free_page_hint_status
== FREE_PAGE_HINT_S_START
) {
548 for (i
= 0; i
< elem
->in_num
; i
++) {
549 qemu_guest_free_page_hint(elem
->in_sg
[i
].iov_base
,
550 elem
->in_sg
[i
].iov_len
);
555 virtqueue_push(vq
, elem
, 0);
560 static void virtio_ballloon_get_free_page_hints(void *opaque
)
562 VirtIOBalloon
*dev
= opaque
;
563 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
564 VirtQueue
*vq
= dev
->free_page_vq
;
565 bool continue_to_get_hints
;
568 qemu_mutex_lock(&dev
->free_page_lock
);
569 virtio_queue_set_notification(vq
, 0);
570 continue_to_get_hints
= get_free_page_hints(dev
);
571 qemu_mutex_unlock(&dev
->free_page_lock
);
572 virtio_notify(vdev
, vq
);
574 * Start to poll the vq once the hinting started. Otherwise, continue
575 * only when there are entries on the vq, which need to be given back.
577 } while (continue_to_get_hints
||
578 dev
->free_page_hint_status
== FREE_PAGE_HINT_S_START
);
579 virtio_queue_set_notification(vq
, 1);
582 static bool virtio_balloon_free_page_support(void *opaque
)
584 VirtIOBalloon
*s
= opaque
;
585 VirtIODevice
*vdev
= VIRTIO_DEVICE(s
);
587 return virtio_vdev_has_feature(vdev
, VIRTIO_BALLOON_F_FREE_PAGE_HINT
);
590 static void virtio_balloon_free_page_start(VirtIOBalloon
*s
)
592 VirtIODevice
*vdev
= VIRTIO_DEVICE(s
);
594 qemu_mutex_lock(&s
->free_page_lock
);
596 if (s
->free_page_hint_cmd_id
== UINT_MAX
) {
597 s
->free_page_hint_cmd_id
= VIRTIO_BALLOON_FREE_PAGE_HINT_CMD_ID_MIN
;
599 s
->free_page_hint_cmd_id
++;
602 s
->free_page_hint_status
= FREE_PAGE_HINT_S_REQUESTED
;
603 qemu_mutex_unlock(&s
->free_page_lock
);
605 virtio_notify_config(vdev
);
608 static void virtio_balloon_free_page_stop(VirtIOBalloon
*s
)
610 VirtIODevice
*vdev
= VIRTIO_DEVICE(s
);
612 if (s
->free_page_hint_status
!= FREE_PAGE_HINT_S_STOP
) {
614 * The lock also guarantees us that the
615 * virtio_ballloon_get_free_page_hints exits after the
616 * free_page_hint_status is set to S_STOP.
618 qemu_mutex_lock(&s
->free_page_lock
);
620 * The guest isn't done hinting, so send a notification
621 * to the guest to actively stop the hinting.
623 s
->free_page_hint_status
= FREE_PAGE_HINT_S_STOP
;
624 qemu_mutex_unlock(&s
->free_page_lock
);
625 virtio_notify_config(vdev
);
629 static void virtio_balloon_free_page_done(VirtIOBalloon
*s
)
631 VirtIODevice
*vdev
= VIRTIO_DEVICE(s
);
633 if (s
->free_page_hint_status
!= FREE_PAGE_HINT_S_DONE
) {
634 /* See virtio_balloon_free_page_stop() */
635 qemu_mutex_lock(&s
->free_page_lock
);
636 s
->free_page_hint_status
= FREE_PAGE_HINT_S_DONE
;
637 qemu_mutex_unlock(&s
->free_page_lock
);
638 virtio_notify_config(vdev
);
643 virtio_balloon_free_page_hint_notify(NotifierWithReturn
*n
, void *data
)
645 VirtIOBalloon
*dev
= container_of(n
, VirtIOBalloon
, free_page_hint_notify
);
646 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
647 PrecopyNotifyData
*pnd
= data
;
649 if (!virtio_balloon_free_page_support(dev
)) {
651 * This is an optimization provided to migration, so just return 0 to
652 * have the normal migration process not affected when this feature is
659 * Pages hinted via qemu_guest_free_page_hint() are cleared from the dirty
660 * bitmap and will not get migrated, especially also not when the postcopy
661 * destination starts using them and requests migration from the source; the
662 * faulting thread will stall until postcopy migration finishes and
663 * all threads are woken up. Let's not start free page hinting if postcopy
666 if (migrate_postcopy_ram()) {
670 switch (pnd
->reason
) {
671 case PRECOPY_NOTIFY_BEFORE_BITMAP_SYNC
:
672 virtio_balloon_free_page_stop(dev
);
674 case PRECOPY_NOTIFY_AFTER_BITMAP_SYNC
:
675 if (vdev
->vm_running
) {
676 virtio_balloon_free_page_start(dev
);
680 * Set S_DONE before migrating the vmstate, so the guest will reuse
681 * all hinted pages once running on the destination. Fall through.
683 case PRECOPY_NOTIFY_CLEANUP
:
685 * Especially, if something goes wrong during precopy or if migration
686 * is canceled, we have to properly communicate S_DONE to the VM.
688 virtio_balloon_free_page_done(dev
);
690 case PRECOPY_NOTIFY_SETUP
:
691 case PRECOPY_NOTIFY_COMPLETE
:
694 virtio_error(vdev
, "%s: %d reason unknown", __func__
, pnd
->reason
);
700 static size_t virtio_balloon_config_size(VirtIOBalloon
*s
)
702 uint64_t features
= s
->host_features
;
704 if (s
->qemu_4_0_config_size
) {
705 return sizeof(struct virtio_balloon_config
);
707 if (virtio_has_feature(features
, VIRTIO_BALLOON_F_PAGE_POISON
)) {
708 return sizeof(struct virtio_balloon_config
);
710 if (virtio_has_feature(features
, VIRTIO_BALLOON_F_FREE_PAGE_HINT
)) {
711 return offsetof(struct virtio_balloon_config
, poison_val
);
713 return offsetof(struct virtio_balloon_config
, free_page_hint_cmd_id
);
716 static void virtio_balloon_get_config(VirtIODevice
*vdev
, uint8_t *config_data
)
718 VirtIOBalloon
*dev
= VIRTIO_BALLOON(vdev
);
719 struct virtio_balloon_config config
= {};
721 config
.num_pages
= cpu_to_le32(dev
->num_pages
);
722 config
.actual
= cpu_to_le32(dev
->actual
);
723 config
.poison_val
= cpu_to_le32(dev
->poison_val
);
725 if (dev
->free_page_hint_status
== FREE_PAGE_HINT_S_REQUESTED
) {
726 config
.free_page_hint_cmd_id
=
727 cpu_to_le32(dev
->free_page_hint_cmd_id
);
728 } else if (dev
->free_page_hint_status
== FREE_PAGE_HINT_S_STOP
) {
729 config
.free_page_hint_cmd_id
=
730 cpu_to_le32(VIRTIO_BALLOON_CMD_ID_STOP
);
731 } else if (dev
->free_page_hint_status
== FREE_PAGE_HINT_S_DONE
) {
732 config
.free_page_hint_cmd_id
=
733 cpu_to_le32(VIRTIO_BALLOON_CMD_ID_DONE
);
736 trace_virtio_balloon_get_config(config
.num_pages
, config
.actual
);
737 memcpy(config_data
, &config
, virtio_balloon_config_size(dev
));
740 static int build_dimm_list(Object
*obj
, void *opaque
)
742 GSList
**list
= opaque
;
744 if (object_dynamic_cast(obj
, TYPE_PC_DIMM
)) {
745 DeviceState
*dev
= DEVICE(obj
);
746 if (dev
->realized
) { /* only realized DIMMs matter */
747 *list
= g_slist_prepend(*list
, dev
);
751 object_child_foreach(obj
, build_dimm_list
, opaque
);
755 static ram_addr_t
get_current_ram_size(void)
757 GSList
*list
= NULL
, *item
;
758 ram_addr_t size
= current_machine
->ram_size
;
760 build_dimm_list(qdev_get_machine(), &list
);
761 for (item
= list
; item
; item
= g_slist_next(item
)) {
762 Object
*obj
= OBJECT(item
->data
);
763 if (!strcmp(object_get_typename(obj
), TYPE_PC_DIMM
)) {
764 size
+= object_property_get_int(obj
, PC_DIMM_SIZE_PROP
,
773 static bool virtio_balloon_page_poison_support(void *opaque
)
775 VirtIOBalloon
*s
= opaque
;
776 VirtIODevice
*vdev
= VIRTIO_DEVICE(s
);
778 return virtio_vdev_has_feature(vdev
, VIRTIO_BALLOON_F_PAGE_POISON
);
781 static void virtio_balloon_set_config(VirtIODevice
*vdev
,
782 const uint8_t *config_data
)
784 VirtIOBalloon
*dev
= VIRTIO_BALLOON(vdev
);
785 struct virtio_balloon_config config
;
786 uint32_t oldactual
= dev
->actual
;
787 ram_addr_t vm_ram_size
= get_current_ram_size();
789 memcpy(&config
, config_data
, virtio_balloon_config_size(dev
));
790 dev
->actual
= le32_to_cpu(config
.actual
);
791 if (dev
->actual
!= oldactual
) {
792 qapi_event_send_balloon_change(vm_ram_size
-
793 ((ram_addr_t
) dev
->actual
<< VIRTIO_BALLOON_PFN_SHIFT
));
796 if (virtio_balloon_page_poison_support(dev
)) {
797 dev
->poison_val
= le32_to_cpu(config
.poison_val
);
799 trace_virtio_balloon_set_config(dev
->actual
, oldactual
);
802 static uint64_t virtio_balloon_get_features(VirtIODevice
*vdev
, uint64_t f
,
805 VirtIOBalloon
*dev
= VIRTIO_BALLOON(vdev
);
806 f
|= dev
->host_features
;
807 virtio_add_feature(&f
, VIRTIO_BALLOON_F_STATS_VQ
);
812 static void virtio_balloon_stat(void *opaque
, BalloonInfo
*info
)
814 VirtIOBalloon
*dev
= opaque
;
815 info
->actual
= get_current_ram_size() - ((uint64_t) dev
->actual
<<
816 VIRTIO_BALLOON_PFN_SHIFT
);
819 static void virtio_balloon_to_target(void *opaque
, ram_addr_t target
)
821 VirtIOBalloon
*dev
= VIRTIO_BALLOON(opaque
);
822 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
823 ram_addr_t vm_ram_size
= get_current_ram_size();
825 if (target
> vm_ram_size
) {
826 target
= vm_ram_size
;
829 dev
->num_pages
= (vm_ram_size
- target
) >> VIRTIO_BALLOON_PFN_SHIFT
;
830 virtio_notify_config(vdev
);
832 trace_virtio_balloon_to_target(target
, dev
->num_pages
);
835 static int virtio_balloon_post_load_device(void *opaque
, int version_id
)
837 VirtIOBalloon
*s
= VIRTIO_BALLOON(opaque
);
839 if (balloon_stats_enabled(s
)) {
840 balloon_stats_change_timer(s
, s
->stats_poll_interval
);
845 static const VMStateDescription vmstate_virtio_balloon_free_page_hint
= {
846 .name
= "virtio-balloon-device/free-page-report",
848 .minimum_version_id
= 1,
849 .needed
= virtio_balloon_free_page_support
,
850 .fields
= (VMStateField
[]) {
851 VMSTATE_UINT32(free_page_hint_cmd_id
, VirtIOBalloon
),
852 VMSTATE_UINT32(free_page_hint_status
, VirtIOBalloon
),
853 VMSTATE_END_OF_LIST()
857 static const VMStateDescription vmstate_virtio_balloon_page_poison
= {
858 .name
= "virtio-balloon-device/page-poison",
860 .minimum_version_id
= 1,
861 .needed
= virtio_balloon_page_poison_support
,
862 .fields
= (VMStateField
[]) {
863 VMSTATE_UINT32(poison_val
, VirtIOBalloon
),
864 VMSTATE_END_OF_LIST()
868 static const VMStateDescription vmstate_virtio_balloon_device
= {
869 .name
= "virtio-balloon-device",
871 .minimum_version_id
= 1,
872 .post_load
= virtio_balloon_post_load_device
,
873 .fields
= (VMStateField
[]) {
874 VMSTATE_UINT32(num_pages
, VirtIOBalloon
),
875 VMSTATE_UINT32(actual
, VirtIOBalloon
),
876 VMSTATE_END_OF_LIST()
878 .subsections
= (const VMStateDescription
* []) {
879 &vmstate_virtio_balloon_free_page_hint
,
880 &vmstate_virtio_balloon_page_poison
,
885 static void virtio_balloon_device_realize(DeviceState
*dev
, Error
**errp
)
887 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
888 VirtIOBalloon
*s
= VIRTIO_BALLOON(dev
);
891 virtio_init(vdev
, "virtio-balloon", VIRTIO_ID_BALLOON
,
892 virtio_balloon_config_size(s
));
894 ret
= qemu_add_balloon_handler(virtio_balloon_to_target
,
895 virtio_balloon_stat
, s
);
898 error_setg(errp
, "Only one balloon device is supported");
899 virtio_cleanup(vdev
);
903 if (virtio_has_feature(s
->host_features
, VIRTIO_BALLOON_F_FREE_PAGE_HINT
) &&
905 error_setg(errp
, "'free-page-hint' requires 'iothread' to be set");
906 virtio_cleanup(vdev
);
910 s
->ivq
= virtio_add_queue(vdev
, 128, virtio_balloon_handle_output
);
911 s
->dvq
= virtio_add_queue(vdev
, 128, virtio_balloon_handle_output
);
912 s
->svq
= virtio_add_queue(vdev
, 128, virtio_balloon_receive_stats
);
914 if (virtio_has_feature(s
->host_features
, VIRTIO_BALLOON_F_FREE_PAGE_HINT
)) {
915 s
->free_page_vq
= virtio_add_queue(vdev
, VIRTQUEUE_MAX_SIZE
,
916 virtio_balloon_handle_free_page_vq
);
917 precopy_add_notifier(&s
->free_page_hint_notify
);
919 object_ref(OBJECT(s
->iothread
));
920 s
->free_page_bh
= aio_bh_new(iothread_get_aio_context(s
->iothread
),
921 virtio_ballloon_get_free_page_hints
, s
);
924 if (virtio_has_feature(s
->host_features
, VIRTIO_BALLOON_F_REPORTING
)) {
925 s
->reporting_vq
= virtio_add_queue(vdev
, 32,
926 virtio_balloon_handle_report
);
932 static void virtio_balloon_device_unrealize(DeviceState
*dev
)
934 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
935 VirtIOBalloon
*s
= VIRTIO_BALLOON(dev
);
937 if (s
->free_page_bh
) {
938 qemu_bh_delete(s
->free_page_bh
);
939 object_unref(OBJECT(s
->iothread
));
940 virtio_balloon_free_page_stop(s
);
941 precopy_remove_notifier(&s
->free_page_hint_notify
);
943 balloon_stats_destroy_timer(s
);
944 qemu_remove_balloon_handler(s
);
946 virtio_delete_queue(s
->ivq
);
947 virtio_delete_queue(s
->dvq
);
948 virtio_delete_queue(s
->svq
);
949 if (s
->free_page_vq
) {
950 virtio_delete_queue(s
->free_page_vq
);
952 if (s
->reporting_vq
) {
953 virtio_delete_queue(s
->reporting_vq
);
955 virtio_cleanup(vdev
);
958 static void virtio_balloon_device_reset(VirtIODevice
*vdev
)
960 VirtIOBalloon
*s
= VIRTIO_BALLOON(vdev
);
962 if (virtio_balloon_free_page_support(s
)) {
963 virtio_balloon_free_page_stop(s
);
966 if (s
->stats_vq_elem
!= NULL
) {
967 virtqueue_unpop(s
->svq
, s
->stats_vq_elem
, 0);
968 g_free(s
->stats_vq_elem
);
969 s
->stats_vq_elem
= NULL
;
975 static void virtio_balloon_set_status(VirtIODevice
*vdev
, uint8_t status
)
977 VirtIOBalloon
*s
= VIRTIO_BALLOON(vdev
);
979 if (!s
->stats_vq_elem
&& vdev
->vm_running
&&
980 (status
& VIRTIO_CONFIG_S_DRIVER_OK
) && virtqueue_rewind(s
->svq
, 1)) {
981 /* poll stats queue for the element we have discarded when the VM
983 virtio_balloon_receive_stats(vdev
, s
->svq
);
986 if (virtio_balloon_free_page_support(s
)) {
988 * The VM is woken up and the iothread was blocked, so signal it to
991 if (vdev
->vm_running
&& s
->block_iothread
) {
992 qemu_mutex_lock(&s
->free_page_lock
);
993 s
->block_iothread
= false;
994 qemu_cond_signal(&s
->free_page_cond
);
995 qemu_mutex_unlock(&s
->free_page_lock
);
998 /* The VM is stopped, block the iothread. */
999 if (!vdev
->vm_running
) {
1000 qemu_mutex_lock(&s
->free_page_lock
);
1001 s
->block_iothread
= true;
1002 qemu_mutex_unlock(&s
->free_page_lock
);
1007 static void virtio_balloon_instance_init(Object
*obj
)
1009 VirtIOBalloon
*s
= VIRTIO_BALLOON(obj
);
1011 qemu_mutex_init(&s
->free_page_lock
);
1012 qemu_cond_init(&s
->free_page_cond
);
1013 s
->free_page_hint_cmd_id
= VIRTIO_BALLOON_FREE_PAGE_HINT_CMD_ID_MIN
;
1014 s
->free_page_hint_notify
.notify
= virtio_balloon_free_page_hint_notify
;
1016 object_property_add(obj
, "guest-stats", "guest statistics",
1017 balloon_stats_get_all
, NULL
, NULL
, s
);
1019 object_property_add(obj
, "guest-stats-polling-interval", "int",
1020 balloon_stats_get_poll_interval
,
1021 balloon_stats_set_poll_interval
,
1025 static const VMStateDescription vmstate_virtio_balloon
= {
1026 .name
= "virtio-balloon",
1027 .minimum_version_id
= 1,
1029 .fields
= (VMStateField
[]) {
1030 VMSTATE_VIRTIO_DEVICE
,
1031 VMSTATE_END_OF_LIST()
1035 static Property virtio_balloon_properties
[] = {
1036 DEFINE_PROP_BIT("deflate-on-oom", VirtIOBalloon
, host_features
,
1037 VIRTIO_BALLOON_F_DEFLATE_ON_OOM
, false),
1038 DEFINE_PROP_BIT("free-page-hint", VirtIOBalloon
, host_features
,
1039 VIRTIO_BALLOON_F_FREE_PAGE_HINT
, false),
1040 DEFINE_PROP_BIT("page-poison", VirtIOBalloon
, host_features
,
1041 VIRTIO_BALLOON_F_PAGE_POISON
, true),
1042 DEFINE_PROP_BIT("free-page-reporting", VirtIOBalloon
, host_features
,
1043 VIRTIO_BALLOON_F_REPORTING
, false),
1044 /* QEMU 4.0 accidentally changed the config size even when free-page-hint
1045 * is disabled, resulting in QEMU 3.1 migration incompatibility. This
1046 * property retains this quirk for QEMU 4.1 machine types.
1048 DEFINE_PROP_BOOL("qemu-4-0-config-size", VirtIOBalloon
,
1049 qemu_4_0_config_size
, false),
1050 DEFINE_PROP_LINK("iothread", VirtIOBalloon
, iothread
, TYPE_IOTHREAD
,
1052 DEFINE_PROP_END_OF_LIST(),
1055 static void virtio_balloon_class_init(ObjectClass
*klass
, void *data
)
1057 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1058 VirtioDeviceClass
*vdc
= VIRTIO_DEVICE_CLASS(klass
);
1060 device_class_set_props(dc
, virtio_balloon_properties
);
1061 dc
->vmsd
= &vmstate_virtio_balloon
;
1062 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
1063 vdc
->realize
= virtio_balloon_device_realize
;
1064 vdc
->unrealize
= virtio_balloon_device_unrealize
;
1065 vdc
->reset
= virtio_balloon_device_reset
;
1066 vdc
->get_config
= virtio_balloon_get_config
;
1067 vdc
->set_config
= virtio_balloon_set_config
;
1068 vdc
->get_features
= virtio_balloon_get_features
;
1069 vdc
->set_status
= virtio_balloon_set_status
;
1070 vdc
->vmsd
= &vmstate_virtio_balloon_device
;
1073 static const TypeInfo virtio_balloon_info
= {
1074 .name
= TYPE_VIRTIO_BALLOON
,
1075 .parent
= TYPE_VIRTIO_DEVICE
,
1076 .instance_size
= sizeof(VirtIOBalloon
),
1077 .instance_init
= virtio_balloon_instance_init
,
1078 .class_init
= virtio_balloon_class_init
,
1081 static void virtio_register_types(void)
1083 type_register_static(&virtio_balloon_info
);
1086 type_init(virtio_register_types
)