1 /* Virtio balloon implementation, inspired by Dor Loar and Marcelo
2 * Tosatti's implementations.
4 * Copyright 2008 Rusty Russell IBM Corporation
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.
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.
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
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 #include <linux/slab.h>
28 #include <linux/module.h>
32 struct virtio_device
*vdev
;
33 struct virtqueue
*inflate_vq
, *deflate_vq
, *stats_vq
;
35 /* Where the ballooning thread waits for config to change. */
36 wait_queue_head_t config_change
;
38 /* The thread servicing the balloon. */
39 struct task_struct
*thread
;
41 /* Waiting for host to ack the pages we released. */
42 struct completion acked
;
44 /* The pages we've told the Host we're not using. */
45 unsigned int num_pages
;
46 struct list_head pages
;
48 /* The array of pfns we tell the Host about. */
49 unsigned int num_pfns
;
52 /* Memory statistics */
53 int need_stats_update
;
54 struct virtio_balloon_stat stats
[VIRTIO_BALLOON_S_NR
];
57 static struct virtio_device_id id_table
[] = {
58 { VIRTIO_ID_BALLOON
, VIRTIO_DEV_ANY_ID
},
62 static u32
page_to_balloon_pfn(struct page
*page
)
64 unsigned long pfn
= page_to_pfn(page
);
66 BUILD_BUG_ON(PAGE_SHIFT
< VIRTIO_BALLOON_PFN_SHIFT
);
67 /* Convert pfn from Linux page size to balloon page size. */
68 return pfn
>> (PAGE_SHIFT
- VIRTIO_BALLOON_PFN_SHIFT
);
71 static void balloon_ack(struct virtqueue
*vq
)
73 struct virtio_balloon
*vb
;
76 vb
= virtqueue_get_buf(vq
, &len
);
81 static void tell_host(struct virtio_balloon
*vb
, struct virtqueue
*vq
)
83 struct scatterlist sg
;
85 sg_init_one(&sg
, vb
->pfns
, sizeof(vb
->pfns
[0]) * vb
->num_pfns
);
87 init_completion(&vb
->acked
);
89 /* We should always be able to add one buffer to an empty queue. */
90 if (virtqueue_add_buf(vq
, &sg
, 1, 0, vb
) < 0)
94 /* When host has read buffer, this completes via balloon_ack */
95 wait_for_completion(&vb
->acked
);
98 static void fill_balloon(struct virtio_balloon
*vb
, size_t num
)
100 /* We can only do one array worth at a time. */
101 num
= min(num
, ARRAY_SIZE(vb
->pfns
));
103 for (vb
->num_pfns
= 0; vb
->num_pfns
< num
; vb
->num_pfns
++) {
104 struct page
*page
= alloc_page(GFP_HIGHUSER
| __GFP_NORETRY
|
105 __GFP_NOMEMALLOC
| __GFP_NOWARN
);
107 if (printk_ratelimit())
108 dev_printk(KERN_INFO
, &vb
->vdev
->dev
,
109 "Out of puff! Can't get %zu pages\n",
111 /* Sleep for at least 1/5 of a second before retry. */
115 vb
->pfns
[vb
->num_pfns
] = page_to_balloon_pfn(page
);
118 list_add(&page
->lru
, &vb
->pages
);
121 /* Didn't get any? Oh well. */
122 if (vb
->num_pfns
== 0)
125 tell_host(vb
, vb
->inflate_vq
);
128 static void release_pages_by_pfn(const u32 pfns
[], unsigned int num
)
132 for (i
= 0; i
< num
; i
++) {
133 __free_page(pfn_to_page(pfns
[i
]));
138 static void leak_balloon(struct virtio_balloon
*vb
, size_t num
)
142 /* We can only do one array worth at a time. */
143 num
= min(num
, ARRAY_SIZE(vb
->pfns
));
145 for (vb
->num_pfns
= 0; vb
->num_pfns
< num
; vb
->num_pfns
++) {
146 page
= list_first_entry(&vb
->pages
, struct page
, lru
);
147 list_del(&page
->lru
);
148 vb
->pfns
[vb
->num_pfns
] = page_to_balloon_pfn(page
);
155 * virtio_has_feature(vdev, VIRTIO_BALLOON_F_MUST_TELL_HOST);
156 * is true, we *have* to do it in this order
158 tell_host(vb
, vb
->deflate_vq
);
159 release_pages_by_pfn(vb
->pfns
, vb
->num_pfns
);
162 static inline void update_stat(struct virtio_balloon
*vb
, int idx
,
165 BUG_ON(idx
>= VIRTIO_BALLOON_S_NR
);
166 vb
->stats
[idx
].tag
= tag
;
167 vb
->stats
[idx
].val
= val
;
170 #define pages_to_bytes(x) ((u64)(x) << PAGE_SHIFT)
172 static void update_balloon_stats(struct virtio_balloon
*vb
)
174 unsigned long events
[NR_VM_EVENT_ITEMS
];
178 all_vm_events(events
);
181 update_stat(vb
, idx
++, VIRTIO_BALLOON_S_SWAP_IN
,
182 pages_to_bytes(events
[PSWPIN
]));
183 update_stat(vb
, idx
++, VIRTIO_BALLOON_S_SWAP_OUT
,
184 pages_to_bytes(events
[PSWPOUT
]));
185 update_stat(vb
, idx
++, VIRTIO_BALLOON_S_MAJFLT
, events
[PGMAJFAULT
]);
186 update_stat(vb
, idx
++, VIRTIO_BALLOON_S_MINFLT
, events
[PGFAULT
]);
187 update_stat(vb
, idx
++, VIRTIO_BALLOON_S_MEMFREE
,
188 pages_to_bytes(i
.freeram
));
189 update_stat(vb
, idx
++, VIRTIO_BALLOON_S_MEMTOT
,
190 pages_to_bytes(i
.totalram
));
194 * While most virtqueues communicate guest-initiated requests to the hypervisor,
195 * the stats queue operates in reverse. The driver initializes the virtqueue
196 * with a single buffer. From that point forward, all conversations consist of
197 * a hypervisor request (a call to this function) which directs us to refill
198 * the virtqueue with a fresh stats buffer. Since stats collection can sleep,
199 * we notify our kthread which does the actual work via stats_handle_request().
201 static void stats_request(struct virtqueue
*vq
)
203 struct virtio_balloon
*vb
;
206 vb
= virtqueue_get_buf(vq
, &len
);
209 vb
->need_stats_update
= 1;
210 wake_up(&vb
->config_change
);
213 static void stats_handle_request(struct virtio_balloon
*vb
)
215 struct virtqueue
*vq
;
216 struct scatterlist sg
;
218 vb
->need_stats_update
= 0;
219 update_balloon_stats(vb
);
222 sg_init_one(&sg
, vb
->stats
, sizeof(vb
->stats
));
223 if (virtqueue_add_buf(vq
, &sg
, 1, 0, vb
) < 0)
228 static void virtballoon_changed(struct virtio_device
*vdev
)
230 struct virtio_balloon
*vb
= vdev
->priv
;
232 wake_up(&vb
->config_change
);
235 static inline s64
towards_target(struct virtio_balloon
*vb
)
238 vb
->vdev
->config
->get(vb
->vdev
,
239 offsetof(struct virtio_balloon_config
, num_pages
),
241 return (s64
)v
- vb
->num_pages
;
244 static void update_balloon_size(struct virtio_balloon
*vb
)
246 __le32 actual
= cpu_to_le32(vb
->num_pages
);
248 vb
->vdev
->config
->set(vb
->vdev
,
249 offsetof(struct virtio_balloon_config
, actual
),
250 &actual
, sizeof(actual
));
253 static int balloon(void *_vballoon
)
255 struct virtio_balloon
*vb
= _vballoon
;
258 while (!kthread_should_stop()) {
262 wait_event_interruptible(vb
->config_change
,
263 (diff
= towards_target(vb
)) != 0
264 || vb
->need_stats_update
265 || kthread_should_stop()
266 || freezing(current
));
267 if (vb
->need_stats_update
)
268 stats_handle_request(vb
);
270 fill_balloon(vb
, diff
);
272 leak_balloon(vb
, -diff
);
273 update_balloon_size(vb
);
278 static int virtballoon_probe(struct virtio_device
*vdev
)
280 struct virtio_balloon
*vb
;
281 struct virtqueue
*vqs
[3];
282 vq_callback_t
*callbacks
[] = { balloon_ack
, balloon_ack
, stats_request
};
283 const char *names
[] = { "inflate", "deflate", "stats" };
286 vdev
->priv
= vb
= kmalloc(sizeof(*vb
), GFP_KERNEL
);
292 INIT_LIST_HEAD(&vb
->pages
);
294 init_waitqueue_head(&vb
->config_change
);
296 vb
->need_stats_update
= 0;
298 /* We expect two virtqueues: inflate and deflate,
299 * and optionally stat. */
300 nvqs
= virtio_has_feature(vb
->vdev
, VIRTIO_BALLOON_F_STATS_VQ
) ? 3 : 2;
301 err
= vdev
->config
->find_vqs(vdev
, nvqs
, vqs
, callbacks
, names
);
305 vb
->inflate_vq
= vqs
[0];
306 vb
->deflate_vq
= vqs
[1];
307 if (virtio_has_feature(vb
->vdev
, VIRTIO_BALLOON_F_STATS_VQ
)) {
308 struct scatterlist sg
;
309 vb
->stats_vq
= vqs
[2];
312 * Prime this virtqueue with one buffer so the hypervisor can
313 * use it to signal us later.
315 sg_init_one(&sg
, vb
->stats
, sizeof vb
->stats
);
316 if (virtqueue_add_buf(vb
->stats_vq
, &sg
, 1, 0, vb
) < 0)
318 virtqueue_kick(vb
->stats_vq
);
321 vb
->thread
= kthread_run(balloon
, vb
, "vballoon");
322 if (IS_ERR(vb
->thread
)) {
323 err
= PTR_ERR(vb
->thread
);
330 vdev
->config
->del_vqs(vdev
);
337 static void __devexit
virtballoon_remove(struct virtio_device
*vdev
)
339 struct virtio_balloon
*vb
= vdev
->priv
;
341 kthread_stop(vb
->thread
);
343 /* There might be pages left in the balloon: free them. */
344 while (vb
->num_pages
)
345 leak_balloon(vb
, vb
->num_pages
);
347 /* Now we reset the device so we can clean up the queues. */
348 vdev
->config
->reset(vdev
);
350 vdev
->config
->del_vqs(vdev
);
354 static unsigned int features
[] = {
355 VIRTIO_BALLOON_F_MUST_TELL_HOST
,
356 VIRTIO_BALLOON_F_STATS_VQ
,
359 static struct virtio_driver virtio_balloon_driver
= {
360 .feature_table
= features
,
361 .feature_table_size
= ARRAY_SIZE(features
),
362 .driver
.name
= KBUILD_MODNAME
,
363 .driver
.owner
= THIS_MODULE
,
364 .id_table
= id_table
,
365 .probe
= virtballoon_probe
,
366 .remove
= __devexit_p(virtballoon_remove
),
367 .config_changed
= virtballoon_changed
,
370 static int __init
init(void)
372 return register_virtio_driver(&virtio_balloon_driver
);
375 static void __exit
fini(void)
377 unregister_virtio_driver(&virtio_balloon_driver
);
382 MODULE_DEVICE_TABLE(virtio
, id_table
);
383 MODULE_DESCRIPTION("Virtio balloon driver");
384 MODULE_LICENSE("GPL");