1 /* Virtio balloon implementation, inspired by Dor Loar and Marcelo 2 * Tosatti's implementations. 3 * 4 * Copyright 2008 Rusty Russell IBM Corporation 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 19 */ 20 //#define DEBUG 21 #include <linux/virtio.h> 22 #include <linux/virtio_balloon.h> 23 #include <linux/swap.h> 24 #include <linux/kthread.h> 25 #include <linux/freezer.h> 26 #include <linux/delay.h> 27 28 struct virtio_balloon 29 { 30 struct virtio_device *vdev; 31 struct virtqueue *inflate_vq, *deflate_vq; 32 33 /* Where the ballooning thread waits for config to change. */ 34 wait_queue_head_t config_change; 35 36 /* The thread servicing the balloon. */ 37 struct task_struct *thread; 38 39 /* Waiting for host to ack the pages we released. */ 40 struct completion acked; 41 42 /* Do we have to tell Host *before* we reuse pages? */ 43 bool tell_host_first; 44 45 /* The pages we've told the Host we're not using. */ 46 unsigned int num_pages; 47 struct list_head pages; 48 49 /* The array of pfns we tell the Host about. */ 50 unsigned int num_pfns; 51 u32 pfns[256]; 52 }; 53 54 static struct virtio_device_id id_table[] = { 55 { VIRTIO_ID_BALLOON, VIRTIO_DEV_ANY_ID }, 56 { 0 }, 57 }; 58 59 static void balloon_ack(struct virtqueue *vq) 60 { 61 struct virtio_balloon *vb; 62 unsigned int len; 63 64 vb = vq->vq_ops->get_buf(vq, &len); 65 if (vb) 66 complete(&vb->acked); 67 } 68 69 static void tell_host(struct virtio_balloon *vb, struct virtqueue *vq) 70 { 71 struct scatterlist sg; 72 73 sg_init_one(&sg, vb->pfns, sizeof(vb->pfns[0]) * vb->num_pfns); 74 75 init_completion(&vb->acked); 76 77 /* We should always be able to add one buffer to an empty queue. */ 78 if (vq->vq_ops->add_buf(vq, &sg, 1, 0, vb) != 0) 79 BUG(); 80 vq->vq_ops->kick(vq); 81 82 /* When host has read buffer, this completes via balloon_ack */ 83 wait_for_completion(&vb->acked); 84 } 85 86 static void fill_balloon(struct virtio_balloon *vb, size_t num) 87 { 88 /* We can only do one array worth at a time. */ 89 num = min(num, ARRAY_SIZE(vb->pfns)); 90 91 for (vb->num_pfns = 0; vb->num_pfns < num; vb->num_pfns++) { 92 struct page *page = alloc_page(GFP_HIGHUSER | __GFP_NORETRY); 93 if (!page) { 94 if (printk_ratelimit()) 95 dev_printk(KERN_INFO, &vb->vdev->dev, 96 "Out of puff! Can't get %zu pages\n", 97 num); 98 /* Sleep for at least 1/5 of a second before retry. */ 99 msleep(200); 100 break; 101 } 102 vb->pfns[vb->num_pfns] = page_to_pfn(page); 103 totalram_pages--; 104 vb->num_pages++; 105 list_add(&page->lru, &vb->pages); 106 } 107 108 /* Didn't get any? Oh well. */ 109 if (vb->num_pfns == 0) 110 return; 111 112 tell_host(vb, vb->inflate_vq); 113 } 114 115 static void release_pages_by_pfn(const u32 pfns[], unsigned int num) 116 { 117 unsigned int i; 118 119 for (i = 0; i < num; i++) { 120 __free_page(pfn_to_page(pfns[i])); 121 totalram_pages++; 122 } 123 } 124 125 static void leak_balloon(struct virtio_balloon *vb, size_t num) 126 { 127 struct page *page; 128 129 /* We can only do one array worth at a time. */ 130 num = min(num, ARRAY_SIZE(vb->pfns)); 131 132 for (vb->num_pfns = 0; vb->num_pfns < num; vb->num_pfns++) { 133 page = list_first_entry(&vb->pages, struct page, lru); 134 list_del(&page->lru); 135 vb->pfns[vb->num_pfns] = page_to_pfn(page); 136 vb->num_pages--; 137 } 138 139 if (vb->tell_host_first) { 140 tell_host(vb, vb->deflate_vq); 141 release_pages_by_pfn(vb->pfns, vb->num_pfns); 142 } else { 143 release_pages_by_pfn(vb->pfns, vb->num_pfns); 144 tell_host(vb, vb->deflate_vq); 145 } 146 } 147 148 static void virtballoon_changed(struct virtio_device *vdev) 149 { 150 struct virtio_balloon *vb = vdev->priv; 151 152 wake_up(&vb->config_change); 153 } 154 155 static inline s64 towards_target(struct virtio_balloon *vb) 156 { 157 u32 v; 158 __virtio_config_val(vb->vdev, 159 offsetof(struct virtio_balloon_config, num_pages), 160 &v); 161 return v - vb->num_pages; 162 } 163 164 static void update_balloon_size(struct virtio_balloon *vb) 165 { 166 __le32 actual = cpu_to_le32(vb->num_pages); 167 168 vb->vdev->config->set(vb->vdev, 169 offsetof(struct virtio_balloon_config, actual), 170 &actual, sizeof(actual)); 171 } 172 173 static int balloon(void *_vballoon) 174 { 175 struct virtio_balloon *vb = _vballoon; 176 177 set_freezable(); 178 while (!kthread_should_stop()) { 179 s64 diff; 180 181 try_to_freeze(); 182 wait_event_interruptible(vb->config_change, 183 (diff = towards_target(vb)) != 0 184 || kthread_should_stop()); 185 if (diff > 0) 186 fill_balloon(vb, diff); 187 else if (diff < 0) 188 leak_balloon(vb, -diff); 189 update_balloon_size(vb); 190 } 191 return 0; 192 } 193 194 static int virtballoon_probe(struct virtio_device *vdev) 195 { 196 struct virtio_balloon *vb; 197 int err; 198 199 vdev->priv = vb = kmalloc(sizeof(*vb), GFP_KERNEL); 200 if (!vb) { 201 err = -ENOMEM; 202 goto out; 203 } 204 205 INIT_LIST_HEAD(&vb->pages); 206 vb->num_pages = 0; 207 init_waitqueue_head(&vb->config_change); 208 vb->vdev = vdev; 209 210 /* We expect two virtqueues. */ 211 vb->inflate_vq = vdev->config->find_vq(vdev, 0, balloon_ack); 212 if (IS_ERR(vb->inflate_vq)) { 213 err = PTR_ERR(vb->inflate_vq); 214 goto out_free_vb; 215 } 216 217 vb->deflate_vq = vdev->config->find_vq(vdev, 1, balloon_ack); 218 if (IS_ERR(vb->deflate_vq)) { 219 err = PTR_ERR(vb->deflate_vq); 220 goto out_del_inflate_vq; 221 } 222 223 vb->thread = kthread_run(balloon, vb, "vballoon"); 224 if (IS_ERR(vb->thread)) { 225 err = PTR_ERR(vb->thread); 226 goto out_del_deflate_vq; 227 } 228 229 vb->tell_host_first 230 = vdev->config->feature(vdev, VIRTIO_BALLOON_F_MUST_TELL_HOST); 231 232 return 0; 233 234 out_del_deflate_vq: 235 vdev->config->del_vq(vb->deflate_vq); 236 out_del_inflate_vq: 237 vdev->config->del_vq(vb->inflate_vq); 238 out_free_vb: 239 kfree(vb); 240 out: 241 return err; 242 } 243 244 static void virtballoon_remove(struct virtio_device *vdev) 245 { 246 struct virtio_balloon *vb = vdev->priv; 247 248 kthread_stop(vb->thread); 249 250 /* There might be pages left in the balloon: free them. */ 251 while (vb->num_pages) 252 leak_balloon(vb, vb->num_pages); 253 254 /* Now we reset the device so we can clean up the queues. */ 255 vdev->config->reset(vdev); 256 257 vdev->config->del_vq(vb->deflate_vq); 258 vdev->config->del_vq(vb->inflate_vq); 259 kfree(vb); 260 } 261 262 static struct virtio_driver virtio_balloon = { 263 .driver.name = KBUILD_MODNAME, 264 .driver.owner = THIS_MODULE, 265 .id_table = id_table, 266 .probe = virtballoon_probe, 267 .remove = __devexit_p(virtballoon_remove), 268 .config_changed = virtballoon_changed, 269 }; 270 271 static int __init init(void) 272 { 273 return register_virtio_driver(&virtio_balloon); 274 } 275 276 static void __exit fini(void) 277 { 278 unregister_virtio_driver(&virtio_balloon); 279 } 280 module_init(init); 281 module_exit(fini); 282 283 MODULE_DEVICE_TABLE(virtio, id_table); 284 MODULE_DESCRIPTION("Virtio balloon driver"); 285 MODULE_LICENSE("GPL"); 286