4 * Copyright IBM, Corp. 2008
7 * Anthony Liguori <aliguori@us.ibm.com>
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
15 #include "qemu-common.h"
22 #include "virtio-balloon.h"
29 #if defined(__linux__)
33 typedef struct VirtIOBalloon
36 VirtQueue
*ivq
, *dvq
, *svq
;
39 uint64_t stats
[VIRTIO_BALLOON_S_NR
];
40 VirtQueueElement stats_vq_elem
;
41 size_t stats_vq_offset
;
42 MonitorCompletion
*stats_callback
;
43 void *stats_opaque_callback_data
;
46 static VirtIOBalloon
*to_virtio_balloon(VirtIODevice
*vdev
)
48 return (VirtIOBalloon
*)vdev
;
51 static void balloon_page(void *addr
, int deflate
)
53 #if defined(__linux__)
54 if (!kvm_enabled() || kvm_has_sync_mmu())
55 madvise(addr
, TARGET_PAGE_SIZE
,
56 deflate
? MADV_WILLNEED
: MADV_DONTNEED
);
61 * reset_stats - Mark all items in the stats array as unset
63 * This function needs to be called at device intialization and before
64 * before updating to a set of newly-generated stats. This will ensure that no
65 * stale values stick around in case the guest reports a subset of the supported
68 static inline void reset_stats(VirtIOBalloon
*dev
)
71 for (i
= 0; i
< VIRTIO_BALLOON_S_NR
; dev
->stats
[i
++] = -1);
74 static void stat_put(QDict
*dict
, const char *label
, uint64_t val
)
77 qdict_put(dict
, label
, qint_from_int(val
));
80 static QObject
*get_stats_qobject(VirtIOBalloon
*dev
)
82 QDict
*dict
= qdict_new();
83 uint64_t actual
= ram_size
- ((uint64_t) dev
->actual
<<
84 VIRTIO_BALLOON_PFN_SHIFT
);
86 stat_put(dict
, "actual", actual
);
87 stat_put(dict
, "mem_swapped_in", dev
->stats
[VIRTIO_BALLOON_S_SWAP_IN
]);
88 stat_put(dict
, "mem_swapped_out", dev
->stats
[VIRTIO_BALLOON_S_SWAP_OUT
]);
89 stat_put(dict
, "major_page_faults", dev
->stats
[VIRTIO_BALLOON_S_MAJFLT
]);
90 stat_put(dict
, "minor_page_faults", dev
->stats
[VIRTIO_BALLOON_S_MINFLT
]);
91 stat_put(dict
, "free_mem", dev
->stats
[VIRTIO_BALLOON_S_MEMFREE
]);
92 stat_put(dict
, "total_mem", dev
->stats
[VIRTIO_BALLOON_S_MEMTOT
]);
97 static void virtio_balloon_handle_output(VirtIODevice
*vdev
, VirtQueue
*vq
)
99 VirtIOBalloon
*s
= to_virtio_balloon(vdev
);
100 VirtQueueElement elem
;
102 while (virtqueue_pop(vq
, &elem
)) {
106 while (iov_to_buf(elem
.out_sg
, elem
.out_num
, &pfn
, offset
, 4) == 4) {
110 pa
= (ram_addr_t
)ldl_p(&pfn
) << VIRTIO_BALLOON_PFN_SHIFT
;
113 addr
= cpu_get_physical_page_desc(pa
);
114 if ((addr
& ~TARGET_PAGE_MASK
) != IO_MEM_RAM
)
117 /* Using qemu_get_ram_ptr is bending the rules a bit, but
118 should be OK because we only want a single page. */
119 balloon_page(qemu_get_ram_ptr(addr
), !!(vq
== s
->dvq
));
122 virtqueue_push(vq
, &elem
, offset
);
123 virtio_notify(vdev
, vq
);
127 static void complete_stats_request(VirtIOBalloon
*vb
)
131 if (!vb
->stats_opaque_callback_data
)
134 stats
= get_stats_qobject(vb
);
135 vb
->stats_callback(vb
->stats_opaque_callback_data
, stats
);
136 qobject_decref(stats
);
137 vb
->stats_opaque_callback_data
= NULL
;
138 vb
->stats_callback
= NULL
;
141 static void virtio_balloon_receive_stats(VirtIODevice
*vdev
, VirtQueue
*vq
)
143 VirtIOBalloon
*s
= DO_UPCAST(VirtIOBalloon
, vdev
, vdev
);
144 VirtQueueElement
*elem
= &s
->stats_vq_elem
;
145 VirtIOBalloonStat stat
;
148 if (!virtqueue_pop(vq
, elem
)) {
152 /* Initialize the stats to get rid of any stale values. This is only
153 * needed to handle the case where a guest supports fewer stats than it
154 * used to (ie. it has booted into an old kernel).
158 while (iov_to_buf(elem
->out_sg
, elem
->out_num
, &stat
, offset
, sizeof(stat
))
160 uint16_t tag
= tswap16(stat
.tag
);
161 uint64_t val
= tswap64(stat
.val
);
163 offset
+= sizeof(stat
);
164 if (tag
< VIRTIO_BALLOON_S_NR
)
167 s
->stats_vq_offset
= offset
;
169 complete_stats_request(s
);
172 static void virtio_balloon_get_config(VirtIODevice
*vdev
, uint8_t *config_data
)
174 VirtIOBalloon
*dev
= to_virtio_balloon(vdev
);
175 struct virtio_balloon_config config
;
177 config
.num_pages
= cpu_to_le32(dev
->num_pages
);
178 config
.actual
= cpu_to_le32(dev
->actual
);
180 memcpy(config_data
, &config
, 8);
183 static void virtio_balloon_set_config(VirtIODevice
*vdev
,
184 const uint8_t *config_data
)
186 VirtIOBalloon
*dev
= to_virtio_balloon(vdev
);
187 struct virtio_balloon_config config
;
188 memcpy(&config
, config_data
, 8);
189 dev
->actual
= config
.actual
;
192 static uint32_t virtio_balloon_get_features(VirtIODevice
*vdev
, uint32_t f
)
194 f
|= (1 << VIRTIO_BALLOON_F_STATS_VQ
);
198 static void virtio_balloon_to_target(void *opaque
, ram_addr_t target
,
199 MonitorCompletion cb
, void *cb_data
)
201 VirtIOBalloon
*dev
= opaque
;
203 if (target
> ram_size
)
207 dev
->num_pages
= (ram_size
- target
) >> VIRTIO_BALLOON_PFN_SHIFT
;
208 virtio_notify_config(&dev
->vdev
);
210 /* For now, only allow one request at a time. This restriction can be
211 * removed later by queueing callback and data pairs.
213 if (dev
->stats_callback
!= NULL
) {
216 dev
->stats_callback
= cb
;
217 dev
->stats_opaque_callback_data
= cb_data
;
218 if (dev
->vdev
.guest_features
& (1 << VIRTIO_BALLOON_F_STATS_VQ
)) {
219 virtqueue_push(dev
->svq
, &dev
->stats_vq_elem
, dev
->stats_vq_offset
);
220 virtio_notify(&dev
->vdev
, dev
->svq
);
222 /* Stats are not supported. Clear out any stale values that might
223 * have been set by a more featureful guest kernel.
226 complete_stats_request(dev
);
231 static void virtio_balloon_save(QEMUFile
*f
, void *opaque
)
233 VirtIOBalloon
*s
= opaque
;
235 virtio_save(&s
->vdev
, f
);
237 qemu_put_be32(f
, s
->num_pages
);
238 qemu_put_be32(f
, s
->actual
);
241 static int virtio_balloon_load(QEMUFile
*f
, void *opaque
, int version_id
)
243 VirtIOBalloon
*s
= opaque
;
248 virtio_load(&s
->vdev
, f
);
250 s
->num_pages
= qemu_get_be32(f
);
251 s
->actual
= qemu_get_be32(f
);
255 VirtIODevice
*virtio_balloon_init(DeviceState
*dev
)
259 s
= (VirtIOBalloon
*)virtio_common_init("virtio-balloon",
261 8, sizeof(VirtIOBalloon
));
263 s
->vdev
.get_config
= virtio_balloon_get_config
;
264 s
->vdev
.set_config
= virtio_balloon_set_config
;
265 s
->vdev
.get_features
= virtio_balloon_get_features
;
267 s
->ivq
= virtio_add_queue(&s
->vdev
, 128, virtio_balloon_handle_output
);
268 s
->dvq
= virtio_add_queue(&s
->vdev
, 128, virtio_balloon_handle_output
);
269 s
->svq
= virtio_add_queue(&s
->vdev
, 128, virtio_balloon_receive_stats
);
272 qemu_add_balloon_handler(virtio_balloon_to_target
, s
);
274 register_savevm(dev
, "virtio-balloon", -1, 1,
275 virtio_balloon_save
, virtio_balloon_load
, s
);