hw/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 #include "iov.h"
  17 #include "qemu-common.h"
  18 #include "virtio.h"
  19 #include "pc.h"
  20 #include "cpu.h"
  21 #include "balloon.h"
  22 #include "virtio-balloon.h"
  23 #include "kvm.h"
  24 #include "exec-memory.h"
  25
  26 #if defined(__linux__)
  27 #include <sys/mman.h>
  28 #endif
  29
  30 typedef struct VirtIOBalloon
  31 {
  32     VirtIODevice vdev;
  33     VirtQueue *ivq, *dvq, *svq;
  34     uint32_t num_pages;
  35     uint32_t actual;
  36     uint64_t stats[VIRTIO_BALLOON_S_NR];
  37     VirtQueueElement stats_vq_elem;
  38     size_t stats_vq_offset;
  39     DeviceState *qdev;
  40 } VirtIOBalloon;
  41
  42 static VirtIOBalloon *to_virtio_balloon(VirtIODevice *vdev)
  43 {
  44     return (VirtIOBalloon *)vdev;
  45 }
  46
  47 static void balloon_page(void *addr, int deflate)
  48 {
  49 #if defined(__linux__)
  50     if (!kvm_enabled() || kvm_has_sync_mmu())
  51         qemu_madvise(addr, TARGET_PAGE_SIZE,
  52                 deflate ? QEMU_MADV_WILLNEED : QEMU_MADV_DONTNEED);
  53 #endif
  54 }
  55
  56 /*
  57  * reset_stats - Mark all items in the stats array as unset
  58  *
  59  * This function needs to be called at device intialization and before
  60  * before updating to a set of newly-generated stats.  This will ensure that no
  61  * stale values stick around in case the guest reports a subset of the supported
  62  * statistics.
  63  */
  64 static inline void reset_stats(VirtIOBalloon *dev)
  65 {
  66     int i;
  67     for (i = 0; i < VIRTIO_BALLOON_S_NR; dev->stats[i++] = -1);
  68 }
  69
  70 static void virtio_balloon_handle_output(VirtIODevice *vdev, VirtQueue *vq)
  71 {
  72     VirtIOBalloon *s = to_virtio_balloon(vdev);
  73     VirtQueueElement elem;
  74     MemoryRegionSection section;
  75
  76     while (virtqueue_pop(vq, &elem)) {
  77         size_t offset = 0;
  78         uint32_t pfn;
  79
  80         while (iov_to_buf(elem.out_sg, elem.out_num, &pfn, offset, 4) == 4) {
  81             ram_addr_t pa;
  82             ram_addr_t addr;
  83
  84             pa = (ram_addr_t)ldl_p(&pfn) << VIRTIO_BALLOON_PFN_SHIFT;
  85             offset += 4;
  86
  87             /* FIXME: remove get_system_memory(), but how? */
  88             section = memory_region_find(get_system_memory(), pa, 1);
  89             if (!section.size || !memory_region_is_ram(section.mr))
  90                 continue;
  91
  92             /* Using memory_region_get_ram_ptr is bending the rules a bit, but
  93                should be OK because we only want a single page.  */
  94             addr = section.offset_within_region;
  95             balloon_page(memory_region_get_ram_ptr(section.mr) + addr,
  96                          !!(vq == s->dvq));
  97         }
  98
  99         virtqueue_push(vq, &elem, offset);
 100         virtio_notify(vdev, vq);
 101     }
 102 }
 103
 104 static void virtio_balloon_receive_stats(VirtIODevice *vdev, VirtQueue *vq)
 105 {
 106     VirtIOBalloon *s = DO_UPCAST(VirtIOBalloon, vdev, vdev);
 107     VirtQueueElement *elem = &s->stats_vq_elem;
 108     VirtIOBalloonStat stat;
 109     size_t offset = 0;
 110
 111     if (!virtqueue_pop(vq, elem)) {
 112         return;
 113     }
 114
 115     /* Initialize the stats to get rid of any stale values.  This is only
 116      * needed to handle the case where a guest supports fewer stats than it
 117      * used to (ie. it has booted into an old kernel).
 118      */
 119     reset_stats(s);
 120
 121     while (iov_to_buf(elem->out_sg, elem->out_num, &stat, offset, sizeof(stat))
 122            == sizeof(stat)) {
 123         uint16_t tag = tswap16(stat.tag);
 124         uint64_t val = tswap64(stat.val);
 125
 126         offset += sizeof(stat);
 127         if (tag < VIRTIO_BALLOON_S_NR)
 128             s->stats[tag] = val;
 129     }
 130     s->stats_vq_offset = offset;
 131 }
 132
 133 static void virtio_balloon_get_config(VirtIODevice *vdev, uint8_t *config_data)
 134 {
 135     VirtIOBalloon *dev = to_virtio_balloon(vdev);
 136     struct virtio_balloon_config config;
 137
 138     config.num_pages = cpu_to_le32(dev->num_pages);
 139     config.actual = cpu_to_le32(dev->actual);
 140
 141     memcpy(config_data, &config, 8);
 142 }
 143
 144 static void virtio_balloon_set_config(VirtIODevice *vdev,
 145                                       const uint8_t *config_data)
 146 {
 147     VirtIOBalloon *dev = to_virtio_balloon(vdev);
 148     struct virtio_balloon_config config;
 149     memcpy(&config, config_data, 8);
 150     dev->actual = le32_to_cpu(config.actual);
 151 }
 152
 153 static uint32_t virtio_balloon_get_features(VirtIODevice *vdev, uint32_t f)
 154 {
 155     f |= (1 << VIRTIO_BALLOON_F_STATS_VQ);
 156     return f;
 157 }
 158
 159 static void virtio_balloon_stat(void *opaque, BalloonInfo *info)
 160 {
 161     VirtIOBalloon *dev = opaque;
 162
 163 #if 0
 164     /* Disable guest-provided stats for now. For more details please check:
 165      * https://bugzilla.redhat.com/show_bug.cgi?id=623903
 166      *
 167      * If you do enable it (which is probably not going to happen as we
 168      * need a new command for it), remember that you also need to fill the
 169      * appropriate members of the BalloonInfo structure so that the stats
 170      * are returned to the client.
 171      */
 172     if (dev->vdev.guest_features & (1 << VIRTIO_BALLOON_F_STATS_VQ)) {
 173         virtqueue_push(dev->svq, &dev->stats_vq_elem, dev->stats_vq_offset);
 174         virtio_notify(&dev->vdev, dev->svq);
 175         return;
 176     }
 177 #endif
 178
 179     /* Stats are not supported.  Clear out any stale values that might
 180      * have been set by a more featureful guest kernel.
 181      */
 182     reset_stats(dev);
 183
 184     info->actual = ram_size - ((uint64_t) dev->actual <<
 185                                VIRTIO_BALLOON_PFN_SHIFT);
 186 }
 187
 188 static void virtio_balloon_to_target(void *opaque, ram_addr_t target)
 189 {
 190     VirtIOBalloon *dev = opaque;
 191
 192     if (target > ram_size) {
 193         target = ram_size;
 194     }
 195     if (target) {
 196         dev->num_pages = (ram_size - target) >> VIRTIO_BALLOON_PFN_SHIFT;
 197         virtio_notify_config(&dev->vdev);
 198     }
 199 }
 200
 201 static void virtio_balloon_save(QEMUFile *f, void *opaque)
 202 {
 203     VirtIOBalloon *s = opaque;
 204
 205     virtio_save(&s->vdev, f);
 206
 207     qemu_put_be32(f, s->num_pages);
 208     qemu_put_be32(f, s->actual);
 209 }
 210
 211 static int virtio_balloon_load(QEMUFile *f, void *opaque, int version_id)
 212 {
 213     VirtIOBalloon *s = opaque;
 214     int ret;
 215
 216     if (version_id != 1)
 217         return -EINVAL;
 218
 219     ret = virtio_load(&s->vdev, f);
 220     if (ret) {
 221         return ret;
 222     }
 223
 224     s->num_pages = qemu_get_be32(f);
 225     s->actual = qemu_get_be32(f);
 226     return 0;
 227 }
 228
 229 VirtIODevice *virtio_balloon_init(DeviceState *dev)
 230 {
 231     VirtIOBalloon *s;
 232     int ret;
 233
 234     s = (VirtIOBalloon *)virtio_common_init("virtio-balloon",
 235                                             VIRTIO_ID_BALLOON,
 236                                             8, sizeof(VirtIOBalloon));
 237
 238     s->vdev.get_config = virtio_balloon_get_config;
 239     s->vdev.set_config = virtio_balloon_set_config;
 240     s->vdev.get_features = virtio_balloon_get_features;
 241
 242     ret = qemu_add_balloon_handler(virtio_balloon_to_target,
 243                                    virtio_balloon_stat, s);
 244     if (ret < 0) {
 245         virtio_cleanup(&s->vdev);
 246         return NULL;
 247     }
 248
 249     s->ivq = virtio_add_queue(&s->vdev, 128, virtio_balloon_handle_output);
 250     s->dvq = virtio_add_queue(&s->vdev, 128, virtio_balloon_handle_output);
 251     s->svq = virtio_add_queue(&s->vdev, 128, virtio_balloon_receive_stats);
 252
 253     reset_stats(s);
 254
 255     s->qdev = dev;
 256     register_savevm(dev, "virtio-balloon", -1, 1,
 257                     virtio_balloon_save, virtio_balloon_load, s);
 258
 259     return &s->vdev;
 260 }
 261
 262 void virtio_balloon_exit(VirtIODevice *vdev)
 263 {
 264     VirtIOBalloon *s = DO_UPCAST(VirtIOBalloon, vdev, vdev);
 265
 266     qemu_remove_balloon_handler(s);
 267     unregister_savevm(s->qdev, "virtio-balloon", s);
 268     virtio_cleanup(vdev);
 269 }