vnc: cleanup surface handling, fix screen corruption bug. (Gerd Hoffmann)
[qemu/mini2440/sniper_sniper_test.git] / hw / virtio-balloon.c
blob0274bf6fc438f717355cc65c80e3a5e7429dfe0d
1 /*
2 * Virtio Block Device
4 * Copyright IBM, Corp. 2008
6 * Authors:
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.
14 #include "qemu-common.h"
15 #include "virtio.h"
16 #include "pc.h"
17 #include "sysemu.h"
18 #include "cpu.h"
19 #include "balloon.h"
20 #include "virtio-balloon.h"
21 #include "kvm.h"
23 #if defined(__linux__)
24 #include <sys/mman.h>
25 #endif
27 typedef struct VirtIOBalloon
29 VirtIODevice vdev;
30 VirtQueue *ivq, *dvq;
31 uint32_t num_pages;
32 uint32_t actual;
33 } VirtIOBalloon;
35 static VirtIOBalloon *to_virtio_balloon(VirtIODevice *vdev)
37 return (VirtIOBalloon *)vdev;
40 static void balloon_page(void *addr, int deflate)
42 #if defined(__linux__)
43 if (!kvm_enabled() || kvm_has_sync_mmu())
44 madvise(addr, TARGET_PAGE_SIZE,
45 deflate ? MADV_WILLNEED : MADV_DONTNEED);
46 #endif
49 /* FIXME: once we do a virtio refactoring, this will get subsumed into common
50 * code */
51 static size_t memcpy_from_iovector(void *data, size_t offset, size_t size,
52 struct iovec *iov, int iovlen)
54 int i;
55 uint8_t *ptr = data;
56 size_t iov_off = 0;
57 size_t data_off = 0;
59 for (i = 0; i < iovlen && size; i++) {
60 if (offset < (iov_off + iov[i].iov_len)) {
61 size_t len = MIN((iov_off + iov[i].iov_len) - offset , size);
63 memcpy(ptr + data_off, iov[i].iov_base + (offset - iov_off), len);
65 data_off += len;
66 offset += len;
67 size -= len;
70 iov_off += iov[i].iov_len;
73 return data_off;
76 static void virtio_balloon_handle_output(VirtIODevice *vdev, VirtQueue *vq)
78 VirtIOBalloon *s = to_virtio_balloon(vdev);
79 VirtQueueElement elem;
81 while (virtqueue_pop(vq, &elem)) {
82 size_t offset = 0;
83 uint32_t pfn;
85 while (memcpy_from_iovector(&pfn, offset, 4,
86 elem.out_sg, elem.out_num) == 4) {
87 ram_addr_t pa;
88 ram_addr_t addr;
90 pa = (ram_addr_t)ldl_p(&pfn) << VIRTIO_BALLOON_PFN_SHIFT;
91 offset += 4;
93 addr = cpu_get_physical_page_desc(pa);
94 if ((addr & ~TARGET_PAGE_MASK) != IO_MEM_RAM)
95 continue;
97 balloon_page(phys_ram_base + addr, !!(vq == s->dvq));
100 virtqueue_push(vq, &elem, offset);
101 virtio_notify(vdev, vq);
105 static void virtio_balloon_get_config(VirtIODevice *vdev, uint8_t *config_data)
107 VirtIOBalloon *dev = to_virtio_balloon(vdev);
108 struct virtio_balloon_config config;
110 config.num_pages = cpu_to_le32(dev->num_pages);
111 config.actual = cpu_to_le32(dev->actual);
113 memcpy(config_data, &config, 8);
116 static void virtio_balloon_set_config(VirtIODevice *vdev,
117 const uint8_t *config_data)
119 VirtIOBalloon *dev = to_virtio_balloon(vdev);
120 struct virtio_balloon_config config;
121 memcpy(&config, config_data, 8);
122 dev->actual = config.actual;
125 static uint32_t virtio_balloon_get_features(VirtIODevice *vdev)
127 return 0;
130 static ram_addr_t virtio_balloon_to_target(void *opaque, ram_addr_t target)
132 VirtIOBalloon *dev = opaque;
134 if (target > ram_size)
135 target = ram_size;
137 if (target) {
138 dev->num_pages = (ram_size - target) >> VIRTIO_BALLOON_PFN_SHIFT;
139 virtio_notify_config(&dev->vdev);
142 return ram_size - (dev->actual << VIRTIO_BALLOON_PFN_SHIFT);
145 static void virtio_balloon_save(QEMUFile *f, void *opaque)
147 VirtIOBalloon *s = opaque;
149 virtio_save(&s->vdev, f);
151 qemu_put_be32(f, s->num_pages);
152 qemu_put_be32(f, s->actual);
155 static int virtio_balloon_load(QEMUFile *f, void *opaque, int version_id)
157 VirtIOBalloon *s = opaque;
159 if (version_id != 1)
160 return -EINVAL;
162 virtio_load(&s->vdev, f);
164 s->num_pages = qemu_get_be32(f);
165 s->actual = qemu_get_be32(f);
167 return 0;
170 void *virtio_balloon_init(PCIBus *bus)
172 VirtIOBalloon *s;
174 s = (VirtIOBalloon *)virtio_init_pci(bus, "virtio-balloon",
175 PCI_VENDOR_ID_REDHAT_QUMRANET,
176 PCI_DEVICE_ID_VIRTIO_BALLOON,
177 PCI_VENDOR_ID_REDHAT_QUMRANET,
178 VIRTIO_ID_BALLOON,
179 PCI_CLASS_MEMORY_RAM, 0x00,
180 8, sizeof(VirtIOBalloon));
181 if (s == NULL)
182 return NULL;
184 s->vdev.get_config = virtio_balloon_get_config;
185 s->vdev.set_config = virtio_balloon_set_config;
186 s->vdev.get_features = virtio_balloon_get_features;
188 s->ivq = virtio_add_queue(&s->vdev, 128, virtio_balloon_handle_output);
189 s->dvq = virtio_add_queue(&s->vdev, 128, virtio_balloon_handle_output);
191 qemu_add_balloon_handler(virtio_balloon_to_target, s);
193 register_savevm("virtio-balloon", -1, 1, virtio_balloon_save, virtio_balloon_load, s);
195 return &s->vdev;