]>
Commit | Line | Data |
---|---|---|
bd322087 | 1 | /* |
d4443cb6 | 2 | * Virtio Balloon Device |
bd322087 AL |
3 | * |
4 | * Copyright IBM, Corp. 2008 | |
d4443cb6 AS |
5 | * Copyright (C) 2011 Red Hat, Inc. |
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" |
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, |
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 | * | |
52f35022 SW |
56 | * This function needs to be called at device initialization and before |
57 | * updating to a set of newly-generated stats. This will ensure that no | |
625a5bef AL |
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) |
68 | { | |
c96caced FK |
69 | VirtIODevice *vdev = VIRTIO_DEVICE(s); |
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)) { | |
bc72ad67 AB |
81 | timer_del(s->stats_timer); |
82 | timer_free(s->stats_timer); | |
7e6ccd9c LC |
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 | { | |
bc72ad67 | 90 | timer_mod(s->stats_timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) + secs * 1000); |
7e6ccd9c LC |
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 | { | |
2ddb16a9 | 111 | Error *err = NULL; |
7e6ccd9c LC |
112 | VirtIOBalloon *s = opaque; |
113 | int i; | |
114 | ||
115 | if (!s->stats_last_update) { | |
116 | error_setg(errp, "guest hasn't updated any stats yet"); | |
117 | return; | |
118 | } | |
119 | ||
2ddb16a9 MA |
120 | visit_start_struct(v, NULL, "guest-stats", name, 0, &err); |
121 | if (err) { | |
122 | goto out; | |
123 | } | |
2ddb16a9 | 124 | visit_type_int(v, &s->stats_last_update, "last-update", &err); |
297a3646 MA |
125 | if (err) { |
126 | goto out_end; | |
127 | } | |
7e6ccd9c | 128 | |
2ddb16a9 MA |
129 | visit_start_struct(v, NULL, NULL, "stats", 0, &err); |
130 | if (err) { | |
131 | goto out_end; | |
132 | } | |
297a3646 | 133 | for (i = 0; !err && i < VIRTIO_BALLOON_S_NR; i++) { |
7e6ccd9c | 134 | visit_type_int64(v, (int64_t *) &s->stats[i], balloon_stat_names[i], |
2ddb16a9 | 135 | &err); |
7e6ccd9c | 136 | } |
297a3646 MA |
137 | error_propagate(errp, err); |
138 | err = NULL; | |
2ddb16a9 MA |
139 | visit_end_struct(v, &err); |
140 | ||
141 | out_end: | |
297a3646 MA |
142 | error_propagate(errp, err); |
143 | err = NULL; | |
2ddb16a9 | 144 | visit_end_struct(v, &err); |
2ddb16a9 MA |
145 | out: |
146 | error_propagate(errp, err); | |
7e6ccd9c LC |
147 | } |
148 | ||
149 | static void balloon_stats_get_poll_interval(Object *obj, struct Visitor *v, | |
150 | void *opaque, const char *name, | |
151 | Error **errp) | |
152 | { | |
153 | VirtIOBalloon *s = opaque; | |
154 | visit_type_int(v, &s->stats_poll_interval, name, errp); | |
155 | } | |
156 | ||
157 | static void balloon_stats_set_poll_interval(Object *obj, struct Visitor *v, | |
158 | void *opaque, const char *name, | |
159 | Error **errp) | |
160 | { | |
161 | VirtIOBalloon *s = opaque; | |
65cd9064 | 162 | Error *local_err = NULL; |
7e6ccd9c LC |
163 | int64_t value; |
164 | ||
65cd9064 MA |
165 | visit_type_int(v, &value, name, &local_err); |
166 | if (local_err) { | |
167 | error_propagate(errp, local_err); | |
7e6ccd9c LC |
168 | return; |
169 | } | |
170 | ||
171 | if (value < 0) { | |
172 | error_setg(errp, "timer value must be greater than zero"); | |
173 | return; | |
174 | } | |
175 | ||
176 | if (value == s->stats_poll_interval) { | |
177 | return; | |
178 | } | |
179 | ||
180 | if (value == 0) { | |
181 | /* timer=0 disables the timer */ | |
182 | balloon_stats_destroy_timer(s); | |
183 | return; | |
184 | } | |
185 | ||
186 | if (balloon_stats_enabled(s)) { | |
187 | /* timer interval change */ | |
188 | s->stats_poll_interval = value; | |
189 | balloon_stats_change_timer(s, value); | |
190 | return; | |
191 | } | |
192 | ||
193 | /* create a new timer */ | |
194 | g_assert(s->stats_timer == NULL); | |
bc72ad67 | 195 | s->stats_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL, balloon_stats_poll_cb, s); |
7e6ccd9c LC |
196 | s->stats_poll_interval = value; |
197 | balloon_stats_change_timer(s, 0); | |
198 | } | |
199 | ||
bd322087 AL |
200 | static void virtio_balloon_handle_output(VirtIODevice *vdev, VirtQueue *vq) |
201 | { | |
c96caced | 202 | VirtIOBalloon *s = VIRTIO_BALLOON(vdev); |
bd322087 | 203 | VirtQueueElement elem; |
b7c28c74 | 204 | MemoryRegionSection section; |
bd322087 AL |
205 | |
206 | while (virtqueue_pop(vq, &elem)) { | |
207 | size_t offset = 0; | |
208 | uint32_t pfn; | |
209 | ||
dcf6f5e1 | 210 | while (iov_to_buf(elem.out_sg, elem.out_num, offset, &pfn, 4) == 4) { |
c227f099 AL |
211 | ram_addr_t pa; |
212 | ram_addr_t addr; | |
bd322087 | 213 | |
c227f099 | 214 | pa = (ram_addr_t)ldl_p(&pfn) << VIRTIO_BALLOON_PFN_SHIFT; |
bd322087 AL |
215 | offset += 4; |
216 | ||
b7c28c74 AK |
217 | /* FIXME: remove get_system_memory(), but how? */ |
218 | section = memory_region_find(get_system_memory(), pa, 1); | |
052e87b0 | 219 | if (!int128_nz(section.size) || !memory_region_is_ram(section.mr)) |
bd322087 AL |
220 | continue; |
221 | ||
b7c28c74 | 222 | /* Using memory_region_get_ram_ptr is bending the rules a bit, but |
5c130f65 | 223 | should be OK because we only want a single page. */ |
b7c28c74 AK |
224 | addr = section.offset_within_region; |
225 | balloon_page(memory_region_get_ram_ptr(section.mr) + addr, | |
226 | !!(vq == s->dvq)); | |
dfde4e6e | 227 | memory_region_unref(section.mr); |
bd322087 AL |
228 | } |
229 | ||
230 | virtqueue_push(vq, &elem, offset); | |
231 | virtio_notify(vdev, vq); | |
232 | } | |
233 | } | |
234 | ||
625a5bef AL |
235 | static void virtio_balloon_receive_stats(VirtIODevice *vdev, VirtQueue *vq) |
236 | { | |
c96caced | 237 | VirtIOBalloon *s = VIRTIO_BALLOON(vdev); |
625a5bef AL |
238 | VirtQueueElement *elem = &s->stats_vq_elem; |
239 | VirtIOBalloonStat stat; | |
240 | size_t offset = 0; | |
7e6ccd9c | 241 | qemu_timeval tv; |
625a5bef AL |
242 | |
243 | if (!virtqueue_pop(vq, elem)) { | |
7e6ccd9c | 244 | goto out; |
625a5bef AL |
245 | } |
246 | ||
247 | /* Initialize the stats to get rid of any stale values. This is only | |
248 | * needed to handle the case where a guest supports fewer stats than it | |
249 | * used to (ie. it has booted into an old kernel). | |
250 | */ | |
251 | reset_stats(s); | |
252 | ||
dcf6f5e1 | 253 | while (iov_to_buf(elem->out_sg, elem->out_num, offset, &stat, sizeof(stat)) |
fa6111f2 | 254 | == sizeof(stat)) { |
625a5bef AL |
255 | uint16_t tag = tswap16(stat.tag); |
256 | uint64_t val = tswap64(stat.val); | |
257 | ||
258 | offset += sizeof(stat); | |
259 | if (tag < VIRTIO_BALLOON_S_NR) | |
260 | s->stats[tag] = val; | |
261 | } | |
262 | s->stats_vq_offset = offset; | |
7e6ccd9c LC |
263 | |
264 | if (qemu_gettimeofday(&tv) < 0) { | |
265 | fprintf(stderr, "warning: %s: failed to get time of day\n", __func__); | |
266 | goto out; | |
267 | } | |
268 | ||
269 | s->stats_last_update = tv.tv_sec; | |
270 | ||
271 | out: | |
272 | if (balloon_stats_enabled(s)) { | |
273 | balloon_stats_change_timer(s, s->stats_poll_interval); | |
274 | } | |
625a5bef AL |
275 | } |
276 | ||
bd322087 AL |
277 | static void virtio_balloon_get_config(VirtIODevice *vdev, uint8_t *config_data) |
278 | { | |
c96caced | 279 | VirtIOBalloon *dev = VIRTIO_BALLOON(vdev); |
bd322087 AL |
280 | struct virtio_balloon_config config; |
281 | ||
282 | config.num_pages = cpu_to_le32(dev->num_pages); | |
283 | config.actual = cpu_to_le32(dev->actual); | |
284 | ||
e6baf613 | 285 | memcpy(config_data, &config, sizeof(struct virtio_balloon_config)); |
bd322087 AL |
286 | } |
287 | ||
288 | static void virtio_balloon_set_config(VirtIODevice *vdev, | |
289 | const uint8_t *config_data) | |
290 | { | |
c96caced | 291 | VirtIOBalloon *dev = VIRTIO_BALLOON(vdev); |
bd322087 | 292 | struct virtio_balloon_config config; |
973603a8 | 293 | uint32_t oldactual = dev->actual; |
e6baf613 | 294 | memcpy(&config, config_data, sizeof(struct virtio_balloon_config)); |
e54f1771 | 295 | dev->actual = le32_to_cpu(config.actual); |
973603a8 DB |
296 | if (dev->actual != oldactual) { |
297 | qemu_balloon_changed(ram_size - | |
dcc6ceff | 298 | ((ram_addr_t) dev->actual << VIRTIO_BALLOON_PFN_SHIFT)); |
973603a8 | 299 | } |
bd322087 AL |
300 | } |
301 | ||
8172539d | 302 | static uint32_t virtio_balloon_get_features(VirtIODevice *vdev, uint32_t f) |
bd322087 | 303 | { |
625a5bef | 304 | f |= (1 << VIRTIO_BALLOON_F_STATS_VQ); |
8172539d | 305 | return f; |
bd322087 AL |
306 | } |
307 | ||
96637bcd | 308 | static void virtio_balloon_stat(void *opaque, BalloonInfo *info) |
dce911c7 AS |
309 | { |
310 | VirtIOBalloon *dev = opaque; | |
96637bcd LC |
311 | info->actual = ram_size - ((uint64_t) dev->actual << |
312 | VIRTIO_BALLOON_PFN_SHIFT); | |
dce911c7 AS |
313 | } |
314 | ||
30fb2ca6 | 315 | static void virtio_balloon_to_target(void *opaque, ram_addr_t target) |
bd322087 | 316 | { |
c96caced FK |
317 | VirtIOBalloon *dev = VIRTIO_BALLOON(opaque); |
318 | VirtIODevice *vdev = VIRTIO_DEVICE(dev); | |
bd322087 | 319 | |
dce911c7 | 320 | if (target > ram_size) { |
bd322087 | 321 | target = ram_size; |
dce911c7 | 322 | } |
bd322087 AL |
323 | if (target) { |
324 | dev->num_pages = (ram_size - target) >> VIRTIO_BALLOON_PFN_SHIFT; | |
c96caced | 325 | virtio_notify_config(vdev); |
bd322087 | 326 | } |
bd322087 AL |
327 | } |
328 | ||
329 | static void virtio_balloon_save(QEMUFile *f, void *opaque) | |
330 | { | |
c96caced FK |
331 | VirtIOBalloon *s = VIRTIO_BALLOON(opaque); |
332 | VirtIODevice *vdev = VIRTIO_DEVICE(s); | |
bd322087 | 333 | |
c96caced | 334 | virtio_save(vdev, f); |
bd322087 AL |
335 | |
336 | qemu_put_be32(f, s->num_pages); | |
337 | qemu_put_be32(f, s->actual); | |
338 | } | |
339 | ||
340 | static int virtio_balloon_load(QEMUFile *f, void *opaque, int version_id) | |
341 | { | |
c96caced FK |
342 | VirtIOBalloon *s = VIRTIO_BALLOON(opaque); |
343 | VirtIODevice *vdev = VIRTIO_DEVICE(s); | |
2a633c46 | 344 | int ret; |
bd322087 AL |
345 | |
346 | if (version_id != 1) | |
347 | return -EINVAL; | |
348 | ||
c96caced | 349 | ret = virtio_load(vdev, f); |
2a633c46 OW |
350 | if (ret) { |
351 | return ret; | |
352 | } | |
bd322087 AL |
353 | |
354 | s->num_pages = qemu_get_be32(f); | |
355 | s->actual = qemu_get_be32(f); | |
bd322087 AL |
356 | return 0; |
357 | } | |
358 | ||
74def47c | 359 | static void virtio_balloon_device_realize(DeviceState *dev, Error **errp) |
bd322087 | 360 | { |
74def47c | 361 | VirtIODevice *vdev = VIRTIO_DEVICE(dev); |
a546fb17 | 362 | VirtIOBalloon *s = VIRTIO_BALLOON(dev); |
f76f6655 | 363 | int ret; |
bd322087 | 364 | |
e6baf613 LC |
365 | virtio_init(vdev, "virtio-balloon", VIRTIO_ID_BALLOON, |
366 | sizeof(struct virtio_balloon_config)); | |
bd322087 | 367 | |
f76f6655 AS |
368 | ret = qemu_add_balloon_handler(virtio_balloon_to_target, |
369 | virtio_balloon_stat, s); | |
5c7d0962 | 370 | |
1ab461b5 | 371 | if (ret < 0) { |
74def47c | 372 | error_setg(errp, "Adding balloon handler failed"); |
a546fb17 | 373 | virtio_cleanup(vdev); |
74def47c | 374 | return; |
1ab461b5 | 375 | } |
f76f6655 | 376 | |
5c7d0962 FK |
377 | s->ivq = virtio_add_queue(vdev, 128, virtio_balloon_handle_output); |
378 | s->dvq = virtio_add_queue(vdev, 128, virtio_balloon_handle_output); | |
379 | s->svq = virtio_add_queue(vdev, 128, virtio_balloon_receive_stats); | |
bd322087 | 380 | |
a546fb17 | 381 | register_savevm(dev, "virtio-balloon", -1, 1, |
0be71e32 | 382 | virtio_balloon_save, virtio_balloon_load, s); |
bd322087 | 383 | |
a546fb17 | 384 | object_property_add(OBJECT(dev), "guest-stats", "guest statistics", |
7e6ccd9c LC |
385 | balloon_stats_get_all, NULL, NULL, s, NULL); |
386 | ||
a546fb17 | 387 | object_property_add(OBJECT(dev), "guest-stats-polling-interval", "int", |
7e6ccd9c LC |
388 | balloon_stats_get_poll_interval, |
389 | balloon_stats_set_poll_interval, | |
390 | NULL, s, NULL); | |
1ab461b5 FK |
391 | } |
392 | ||
306ec6c3 | 393 | static void virtio_balloon_device_unrealize(DeviceState *dev, Error **errp) |
1ab461b5 | 394 | { |
306ec6c3 AF |
395 | VirtIODevice *vdev = VIRTIO_DEVICE(dev); |
396 | VirtIOBalloon *s = VIRTIO_BALLOON(dev); | |
1ab461b5 FK |
397 | |
398 | balloon_stats_destroy_timer(s); | |
399 | qemu_remove_balloon_handler(s); | |
306ec6c3 | 400 | unregister_savevm(dev, "virtio-balloon", s); |
6a1a8cc7 | 401 | virtio_cleanup(vdev); |
1ab461b5 FK |
402 | } |
403 | ||
404 | static Property virtio_balloon_properties[] = { | |
405 | DEFINE_PROP_END_OF_LIST(), | |
406 | }; | |
407 | ||
408 | static void virtio_balloon_class_init(ObjectClass *klass, void *data) | |
409 | { | |
410 | DeviceClass *dc = DEVICE_CLASS(klass); | |
411 | VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass); | |
74def47c | 412 | |
1ab461b5 | 413 | dc->props = virtio_balloon_properties; |
125ee0ed | 414 | set_bit(DEVICE_CATEGORY_MISC, dc->categories); |
74def47c | 415 | vdc->realize = virtio_balloon_device_realize; |
306ec6c3 | 416 | vdc->unrealize = virtio_balloon_device_unrealize; |
1ab461b5 FK |
417 | vdc->get_config = virtio_balloon_get_config; |
418 | vdc->set_config = virtio_balloon_set_config; | |
419 | vdc->get_features = virtio_balloon_get_features; | |
420 | } | |
421 | ||
422 | static const TypeInfo virtio_balloon_info = { | |
423 | .name = TYPE_VIRTIO_BALLOON, | |
424 | .parent = TYPE_VIRTIO_DEVICE, | |
425 | .instance_size = sizeof(VirtIOBalloon), | |
426 | .class_init = virtio_balloon_class_init, | |
427 | }; | |
428 | ||
429 | static void virtio_register_types(void) | |
430 | { | |
431 | type_register_static(&virtio_balloon_info); | |
432 | } | |
433 | ||
434 | type_init(virtio_register_types) |