hw/virtio/virtio-balloon.c

   1 /*
   2  * Virtio Balloon Device
   3  *
   4  * Copyright IBM, Corp. 2008
   5  * Copyright (C) 2011 Red Hat, Inc.
   6  * Copyright (C) 2011 Amit Shah <amit.shah@redhat.com>
   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
  16 #define VMSTATE_VIRTIO_DEVICE_USE_NEW
  17
  18 #include "qemu/osdep.h"
  19 #include "qemu/iov.h"
  20 #include "qemu/timer.h"
  21 #include "qemu-common.h"
  22 #include "hw/virtio/virtio.h"
  23 #include "hw/i386/pc.h"
  24 #include "sysemu/balloon.h"
  25 #include "hw/virtio/virtio-balloon.h"
  26 #include "sysemu/kvm.h"
  27 #include "exec/address-spaces.h"
  28 #include "qapi/visitor.h"
  29 #include "qapi-event.h"
  30 #include "trace.h"
  31
  32 #include "hw/virtio/virtio-bus.h"
  33 #include "hw/virtio/virtio-access.h"
  34
  35 #define BALLOON_PAGE_SIZE  (1 << VIRTIO_BALLOON_PFN_SHIFT)
  36
  37 static void balloon_page(void *addr, int deflate)
  38 {
  39     if (!qemu_balloon_is_inhibited() && (!kvm_enabled() ||
  40                                          kvm_has_sync_mmu())) {
  41         qemu_madvise(addr, BALLOON_PAGE_SIZE,
  42                 deflate ? QEMU_MADV_WILLNEED : QEMU_MADV_DONTNEED);
  43     }
  44 }
  45
  46 static const char *balloon_stat_names[] = {
  47    [VIRTIO_BALLOON_S_SWAP_IN] = "stat-swap-in",
  48    [VIRTIO_BALLOON_S_SWAP_OUT] = "stat-swap-out",
  49    [VIRTIO_BALLOON_S_MAJFLT] = "stat-major-faults",
  50    [VIRTIO_BALLOON_S_MINFLT] = "stat-minor-faults",
  51    [VIRTIO_BALLOON_S_MEMFREE] = "stat-free-memory",
  52    [VIRTIO_BALLOON_S_MEMTOT] = "stat-total-memory",
  53    [VIRTIO_BALLOON_S_AVAIL] = "stat-available-memory",
  54    [VIRTIO_BALLOON_S_NR] = NULL
  55 };
  56
  57 /*
  58  * reset_stats - Mark all items in the stats array as unset
  59  *
  60  * This function needs to be called at device initialization and before
  61  * updating to a set of newly-generated stats.  This will ensure that no
  62  * stale values stick around in case the guest reports a subset of the supported
  63  * statistics.
  64  */
  65 static inline void reset_stats(VirtIOBalloon *dev)
  66 {
  67     int i;
  68     for (i = 0; i < VIRTIO_BALLOON_S_NR; dev->stats[i++] = -1);
  69 }
  70
  71 static bool balloon_stats_supported(const VirtIOBalloon *s)
  72 {
  73     VirtIODevice *vdev = VIRTIO_DEVICE(s);
  74     return virtio_vdev_has_feature(vdev, VIRTIO_BALLOON_F_STATS_VQ);
  75 }
  76
  77 static bool balloon_stats_enabled(const VirtIOBalloon *s)
  78 {
  79     return s->stats_poll_interval > 0;
  80 }
  81
  82 static void balloon_stats_destroy_timer(VirtIOBalloon *s)
  83 {
  84     if (balloon_stats_enabled(s)) {
  85         timer_del(s->stats_timer);
  86         timer_free(s->stats_timer);
  87         s->stats_timer = NULL;
  88         s->stats_poll_interval = 0;
  89     }
  90 }
  91
  92 static void balloon_stats_change_timer(VirtIOBalloon *s, int64_t secs)
  93 {
  94     timer_mod(s->stats_timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) + secs * 1000);
  95 }
  96
  97 static void balloon_stats_poll_cb(void *opaque)
  98 {
  99     VirtIOBalloon *s = opaque;
 100     VirtIODevice *vdev = VIRTIO_DEVICE(s);
 101
 102     if (s->stats_vq_elem == NULL || !balloon_stats_supported(s)) {
 103         /* re-schedule */
 104         balloon_stats_change_timer(s, s->stats_poll_interval);
 105         return;
 106     }
 107
 108     virtqueue_push(s->svq, s->stats_vq_elem, s->stats_vq_offset);
 109     virtio_notify(vdev, s->svq);
 110     g_free(s->stats_vq_elem);
 111     s->stats_vq_elem = NULL;
 112 }
 113
 114 static void balloon_stats_get_all(Object *obj, Visitor *v, const char *name,
 115                                   void *opaque, Error **errp)
 116 {
 117     Error *err = NULL;
 118     VirtIOBalloon *s = opaque;
 119     int i;
 120
 121     visit_start_struct(v, name, NULL, 0, &err);
 122     if (err) {
 123         goto out;
 124     }
 125     visit_type_int(v, "last-update", &s->stats_last_update, &err);
 126     if (err) {
 127         goto out_end;
 128     }
 129
 130     visit_start_struct(v, "stats", NULL, 0, &err);
 131     if (err) {
 132         goto out_end;
 133     }
 134     for (i = 0; i < VIRTIO_BALLOON_S_NR; i++) {
 135         visit_type_uint64(v, balloon_stat_names[i], &s->stats[i], &err);
 136         if (err) {
 137             goto out_nested;
 138         }
 139     }
 140     visit_check_struct(v, &err);
 141 out_nested:
 142     visit_end_struct(v, NULL);
 143
 144     if (!err) {
 145         visit_check_struct(v, &err);
 146     }
 147 out_end:
 148     visit_end_struct(v, NULL);
 149 out:
 150     error_propagate(errp, err);
 151 }
 152
 153 static void balloon_stats_get_poll_interval(Object *obj, Visitor *v,
 154                                             const char *name, void *opaque,
 155                                             Error **errp)
 156 {
 157     VirtIOBalloon *s = opaque;
 158     visit_type_int(v, name, &s->stats_poll_interval, errp);
 159 }
 160
 161 static void balloon_stats_set_poll_interval(Object *obj, Visitor *v,
 162                                             const char *name, void *opaque,
 163                                             Error **errp)
 164 {
 165     VirtIOBalloon *s = opaque;
 166     Error *local_err = NULL;
 167     int64_t value;
 168
 169     visit_type_int(v, name, &value, &local_err);
 170     if (local_err) {
 171         error_propagate(errp, local_err);
 172         return;
 173     }
 174
 175     if (value < 0) {
 176         error_setg(errp, "timer value must be greater than zero");
 177         return;
 178     }
 179
 180     if (value > UINT32_MAX) {
 181         error_setg(errp, "timer value is too big");
 182         return;
 183     }
 184
 185     if (value == s->stats_poll_interval) {
 186         return;
 187     }
 188
 189     if (value == 0) {
 190         /* timer=0 disables the timer */
 191         balloon_stats_destroy_timer(s);
 192         return;
 193     }
 194
 195     if (balloon_stats_enabled(s)) {
 196         /* timer interval change */
 197         s->stats_poll_interval = value;
 198         balloon_stats_change_timer(s, value);
 199         return;
 200     }
 201
 202     /* create a new timer */
 203     g_assert(s->stats_timer == NULL);
 204     s->stats_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL, balloon_stats_poll_cb, s);
 205     s->stats_poll_interval = value;
 206     balloon_stats_change_timer(s, 0);
 207 }
 208
 209 static void virtio_balloon_handle_output(VirtIODevice *vdev, VirtQueue *vq)
 210 {
 211     VirtIOBalloon *s = VIRTIO_BALLOON(vdev);
 212     VirtQueueElement *elem;
 213     MemoryRegionSection section;
 214
 215     for (;;) {
 216         size_t offset = 0;
 217         uint32_t pfn;
 218         elem = virtqueue_pop(vq, sizeof(VirtQueueElement));
 219         if (!elem) {
 220             return;
 221         }
 222
 223         while (iov_to_buf(elem->out_sg, elem->out_num, offset, &pfn, 4) == 4) {
 224             ram_addr_t pa;
 225             ram_addr_t addr;
 226             int p = virtio_ldl_p(vdev, &pfn);
 227
 228             pa = (ram_addr_t) p << VIRTIO_BALLOON_PFN_SHIFT;
 229             offset += 4;
 230
 231             /* FIXME: remove get_system_memory(), but how? */
 232             section = memory_region_find(get_system_memory(), pa, 1);
 233             if (!int128_nz(section.size) || !memory_region_is_ram(section.mr))
 234                 continue;
 235
 236             trace_virtio_balloon_handle_output(memory_region_name(section.mr),
 237                                                pa);
 238             /* Using memory_region_get_ram_ptr is bending the rules a bit, but
 239                should be OK because we only want a single page.  */
 240             addr = section.offset_within_region;
 241             balloon_page(memory_region_get_ram_ptr(section.mr) + addr,
 242                          !!(vq == s->dvq));
 243             memory_region_unref(section.mr);
 244         }
 245
 246         virtqueue_push(vq, elem, offset);
 247         virtio_notify(vdev, vq);
 248         g_free(elem);
 249     }
 250 }
 251
 252 static void virtio_balloon_receive_stats(VirtIODevice *vdev, VirtQueue *vq)
 253 {
 254     VirtIOBalloon *s = VIRTIO_BALLOON(vdev);
 255     VirtQueueElement *elem;
 256     VirtIOBalloonStat stat;
 257     size_t offset = 0;
 258     qemu_timeval tv;
 259
 260     elem = virtqueue_pop(vq, sizeof(VirtQueueElement));
 261     if (!elem) {
 262         goto out;
 263     }
 264
 265     if (s->stats_vq_elem != NULL) {
 266         /* This should never happen if the driver follows the spec. */
 267         virtqueue_push(vq, s->stats_vq_elem, 0);
 268         virtio_notify(vdev, vq);
 269         g_free(s->stats_vq_elem);
 270     }
 271
 272     s->stats_vq_elem = elem;
 273
 274     /* Initialize the stats to get rid of any stale values.  This is only
 275      * needed to handle the case where a guest supports fewer stats than it
 276      * used to (ie. it has booted into an old kernel).
 277      */
 278     reset_stats(s);
 279
 280     while (iov_to_buf(elem->out_sg, elem->out_num, offset, &stat, sizeof(stat))
 281            == sizeof(stat)) {
 282         uint16_t tag = virtio_tswap16(vdev, stat.tag);
 283         uint64_t val = virtio_tswap64(vdev, stat.val);
 284
 285         offset += sizeof(stat);
 286         if (tag < VIRTIO_BALLOON_S_NR)
 287             s->stats[tag] = val;
 288     }
 289     s->stats_vq_offset = offset;
 290
 291     if (qemu_gettimeofday(&tv) < 0) {
 292         fprintf(stderr, "warning: %s: failed to get time of day\n", __func__);
 293         goto out;
 294     }
 295
 296     s->stats_last_update = tv.tv_sec;
 297
 298 out:
 299     if (balloon_stats_enabled(s)) {
 300         balloon_stats_change_timer(s, s->stats_poll_interval);
 301     }
 302 }
 303
 304 static void virtio_balloon_get_config(VirtIODevice *vdev, uint8_t *config_data)
 305 {
 306     VirtIOBalloon *dev = VIRTIO_BALLOON(vdev);
 307     struct virtio_balloon_config config;
 308
 309     config.num_pages = cpu_to_le32(dev->num_pages);
 310     config.actual = cpu_to_le32(dev->actual);
 311
 312     trace_virtio_balloon_get_config(config.num_pages, config.actual);
 313     memcpy(config_data, &config, sizeof(struct virtio_balloon_config));
 314 }
 315
 316 static int build_dimm_list(Object *obj, void *opaque)
 317 {
 318     GSList **list = opaque;
 319
 320     if (object_dynamic_cast(obj, TYPE_PC_DIMM)) {
 321         DeviceState *dev = DEVICE(obj);
 322         if (dev->realized) { /* only realized DIMMs matter */
 323             *list = g_slist_prepend(*list, dev);
 324         }
 325     }
 326
 327     object_child_foreach(obj, build_dimm_list, opaque);
 328     return 0;
 329 }
 330
 331 static ram_addr_t get_current_ram_size(void)
 332 {
 333     GSList *list = NULL, *item;
 334     ram_addr_t size = ram_size;
 335
 336     build_dimm_list(qdev_get_machine(), &list);
 337     for (item = list; item; item = g_slist_next(item)) {
 338         Object *obj = OBJECT(item->data);
 339         if (!strcmp(object_get_typename(obj), TYPE_PC_DIMM)) {
 340             size += object_property_get_int(obj, PC_DIMM_SIZE_PROP,
 341                                             &error_abort);
 342         }
 343     }
 344     g_slist_free(list);
 345
 346     return size;
 347 }
 348
 349 static void virtio_balloon_set_config(VirtIODevice *vdev,
 350                                       const uint8_t *config_data)
 351 {
 352     VirtIOBalloon *dev = VIRTIO_BALLOON(vdev);
 353     struct virtio_balloon_config config;
 354     uint32_t oldactual = dev->actual;
 355     ram_addr_t vm_ram_size = get_current_ram_size();
 356
 357     memcpy(&config, config_data, sizeof(struct virtio_balloon_config));
 358     dev->actual = le32_to_cpu(config.actual);
 359     if (dev->actual != oldactual) {
 360         qapi_event_send_balloon_change(vm_ram_size -
 361                         ((ram_addr_t) dev->actual << VIRTIO_BALLOON_PFN_SHIFT),
 362                         &error_abort);
 363     }
 364     trace_virtio_balloon_set_config(dev->actual, oldactual);
 365 }
 366
 367 static uint64_t virtio_balloon_get_features(VirtIODevice *vdev, uint64_t f,
 368                                             Error **errp)
 369 {
 370     VirtIOBalloon *dev = VIRTIO_BALLOON(vdev);
 371     f |= dev->host_features;
 372     virtio_add_feature(&f, VIRTIO_BALLOON_F_STATS_VQ);
 373     return f;
 374 }
 375
 376 static void virtio_balloon_stat(void *opaque, BalloonInfo *info)
 377 {
 378     VirtIOBalloon *dev = opaque;
 379     info->actual = get_current_ram_size() - ((uint64_t) dev->actual <<
 380                                              VIRTIO_BALLOON_PFN_SHIFT);
 381 }
 382
 383 static void virtio_balloon_to_target(void *opaque, ram_addr_t target)
 384 {
 385     VirtIOBalloon *dev = VIRTIO_BALLOON(opaque);
 386     VirtIODevice *vdev = VIRTIO_DEVICE(dev);
 387     ram_addr_t vm_ram_size = get_current_ram_size();
 388
 389     if (target > vm_ram_size) {
 390         target = vm_ram_size;
 391     }
 392     if (target) {
 393         dev->num_pages = (vm_ram_size - target) >> VIRTIO_BALLOON_PFN_SHIFT;
 394         virtio_notify_config(vdev);
 395     }
 396     trace_virtio_balloon_to_target(target, dev->num_pages);
 397 }
 398
 399 static void virtio_balloon_save_device(VirtIODevice *vdev, QEMUFile *f)
 400 {
 401     VirtIOBalloon *s = VIRTIO_BALLOON(vdev);
 402
 403     qemu_put_be32(f, s->num_pages);
 404     qemu_put_be32(f, s->actual);
 405 }
 406
 407 static int virtio_balloon_load_device(VirtIODevice *vdev, QEMUFile *f,
 408                                       int version_id)
 409 {
 410     VirtIOBalloon *s = VIRTIO_BALLOON(vdev);
 411
 412     s->num_pages = qemu_get_be32(f);
 413     s->actual = qemu_get_be32(f);
 414
 415     if (balloon_stats_enabled(s)) {
 416         balloon_stats_change_timer(s, s->stats_poll_interval);
 417     }
 418     return 0;
 419 }
 420
 421 static void virtio_balloon_device_realize(DeviceState *dev, Error **errp)
 422 {
 423     VirtIODevice *vdev = VIRTIO_DEVICE(dev);
 424     VirtIOBalloon *s = VIRTIO_BALLOON(dev);
 425     int ret;
 426
 427     virtio_init(vdev, "virtio-balloon", VIRTIO_ID_BALLOON,
 428                 sizeof(struct virtio_balloon_config));
 429
 430     ret = qemu_add_balloon_handler(virtio_balloon_to_target,
 431                                    virtio_balloon_stat, s);
 432
 433     if (ret < 0) {
 434         error_setg(errp, "Only one balloon device is supported");
 435         virtio_cleanup(vdev);
 436         return;
 437     }
 438
 439     s->ivq = virtio_add_queue(vdev, 128, virtio_balloon_handle_output);
 440     s->dvq = virtio_add_queue(vdev, 128, virtio_balloon_handle_output);
 441     s->svq = virtio_add_queue(vdev, 128, virtio_balloon_receive_stats);
 442
 443     reset_stats(s);
 444 }
 445
 446 static void virtio_balloon_device_unrealize(DeviceState *dev, Error **errp)
 447 {
 448     VirtIODevice *vdev = VIRTIO_DEVICE(dev);
 449     VirtIOBalloon *s = VIRTIO_BALLOON(dev);
 450
 451     balloon_stats_destroy_timer(s);
 452     qemu_remove_balloon_handler(s);
 453     virtio_cleanup(vdev);
 454 }
 455
 456 static void virtio_balloon_device_reset(VirtIODevice *vdev)
 457 {
 458     VirtIOBalloon *s = VIRTIO_BALLOON(vdev);
 459
 460     if (s->stats_vq_elem != NULL) {
 461         virtqueue_discard(s->svq, s->stats_vq_elem, 0);
 462         g_free(s->stats_vq_elem);
 463         s->stats_vq_elem = NULL;
 464     }
 465 }
 466
 467 static void virtio_balloon_set_status(VirtIODevice *vdev, uint8_t status)
 468 {
 469     VirtIOBalloon *s = VIRTIO_BALLOON(vdev);
 470
 471     if (!s->stats_vq_elem && vdev->vm_running &&
 472         (status & VIRTIO_CONFIG_S_DRIVER_OK) && virtqueue_rewind(s->svq, 1)) {
 473         /* poll stats queue for the element we have discarded when the VM
 474          * was stopped */
 475         virtio_balloon_receive_stats(vdev, s->svq);
 476     }
 477 }
 478
 479 static void virtio_balloon_instance_init(Object *obj)
 480 {
 481     VirtIOBalloon *s = VIRTIO_BALLOON(obj);
 482
 483     object_property_add(obj, "guest-stats", "guest statistics",
 484                         balloon_stats_get_all, NULL, NULL, s, NULL);
 485
 486     object_property_add(obj, "guest-stats-polling-interval", "int",
 487                         balloon_stats_get_poll_interval,
 488                         balloon_stats_set_poll_interval,
 489                         NULL, s, NULL);
 490 }
 491
 492 static const VMStateDescription vmstate_virtio_balloon = {
 493     .name = "virtio-balloon",
 494     .minimum_version_id = 1,
 495     .version_id = 1,
 496     .fields = (VMStateField[]) {
 497         VMSTATE_VIRTIO_DEVICE,
 498         VMSTATE_END_OF_LIST()
 499     },
 500 };
 501
 502 static Property virtio_balloon_properties[] = {
 503     DEFINE_PROP_BIT("deflate-on-oom", VirtIOBalloon, host_features,
 504                     VIRTIO_BALLOON_F_DEFLATE_ON_OOM, false),
 505     DEFINE_PROP_END_OF_LIST(),
 506 };
 507
 508 static void virtio_balloon_class_init(ObjectClass *klass, void *data)
 509 {
 510     DeviceClass *dc = DEVICE_CLASS(klass);
 511     VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
 512
 513     dc->props = virtio_balloon_properties;
 514     dc->vmsd = &vmstate_virtio_balloon;
 515     set_bit(DEVICE_CATEGORY_MISC, dc->categories);
 516     vdc->realize = virtio_balloon_device_realize;
 517     vdc->unrealize = virtio_balloon_device_unrealize;
 518     vdc->reset = virtio_balloon_device_reset;
 519     vdc->get_config = virtio_balloon_get_config;
 520     vdc->set_config = virtio_balloon_set_config;
 521     vdc->get_features = virtio_balloon_get_features;
 522     vdc->save = virtio_balloon_save_device;
 523     vdc->load = virtio_balloon_load_device;
 524     vdc->set_status = virtio_balloon_set_status;
 525 }
 526
 527 static const TypeInfo virtio_balloon_info = {
 528     .name = TYPE_VIRTIO_BALLOON,
 529     .parent = TYPE_VIRTIO_DEVICE,
 530     .instance_size = sizeof(VirtIOBalloon),
 531     .instance_init = virtio_balloon_instance_init,
 532     .class_init = virtio_balloon_class_init,
 533 };
 534
 535 static void virtio_register_types(void)
 536 {
 537     type_register_static(&virtio_balloon_info);
 538 }
 539
 540 type_init(virtio_register_types)