← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/virtio/virtio_balloon.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/virtio/virtio_balloon.c
 
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
#include <linux/slab.h>
 
28
#include <linux/module.h>
 
29
 
 
30
struct virtio_balloon
 
31
{
 
32
        struct virtio_device *vdev;
 
33
        struct virtqueue *inflate_vq, *deflate_vq, *stats_vq;
 
34
 
 
35
        /* Where the ballooning thread waits for config to change. */
 
36
        wait_queue_head_t config_change;
 
37
 
 
38
        /* The thread servicing the balloon. */
 
39
        struct task_struct *thread;
 
40
 
 
41
        /* Waiting for host to ack the pages we released. */
 
42
        struct completion acked;
 
43
 
 
44
        /* The pages we've told the Host we're not using. */
 
45
        unsigned int num_pages;
 
46
        struct list_head pages;
 
47
 
 
48
        /* The array of pfns we tell the Host about. */
 
49
        unsigned int num_pfns;
 
50
        u32 pfns[256];
 
51
 
 
52
        /* Memory statistics */
 
53
        int need_stats_update;
 
54
        struct virtio_balloon_stat stats[VIRTIO_BALLOON_S_NR];
 
55
};
 
56
 
 
57
static struct virtio_device_id id_table[] = {
 
58
        { VIRTIO_ID_BALLOON, VIRTIO_DEV_ANY_ID },
 
59
        { 0 },
 
60
};
 
61
 
 
62
static u32 page_to_balloon_pfn(struct page *page)
 
63
{
 
64
        unsigned long pfn = page_to_pfn(page);
 
65
 
 
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);
 
69
}
 
70
 
 
71
static void balloon_ack(struct virtqueue *vq)
 
72
{
 
73
        struct virtio_balloon *vb;
 
74
        unsigned int len;
 
75
 
 
76
        vb = virtqueue_get_buf(vq, &len);
 
77
        if (vb)
 
78
                complete(&vb->acked);
 
79
}
 
80
 
 
81
static void tell_host(struct virtio_balloon *vb, struct virtqueue *vq)
 
82
{
 
83
        struct scatterlist sg;
 
84
 
 
85
        sg_init_one(&sg, vb->pfns, sizeof(vb->pfns[0]) * vb->num_pfns);
 
86
 
 
87
        init_completion(&vb->acked);
 
88
 
 
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)
 
91
                BUG();
 
92
        virtqueue_kick(vq);
 
93
 
 
94
        /* When host has read buffer, this completes via balloon_ack */
 
95
        wait_for_completion(&vb->acked);
 
96
}
 
97
 
 
98
static void fill_balloon(struct virtio_balloon *vb, size_t num)
 
99
{
 
100
        /* We can only do one array worth at a time. */
 
101
        num = min(num, ARRAY_SIZE(vb->pfns));
 
102
 
 
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);
 
106
                if (!page) {
 
107
                        if (printk_ratelimit())
 
108
                                dev_printk(KERN_INFO, &vb->vdev->dev,
 
109
                                           "Out of puff! Can't get %zu pages\n",
 
110
                                           num);
 
111
                        /* Sleep for at least 1/5 of a second before retry. */
 
112
                        msleep(200);
 
113
                        break;
 
114
                }
 
115
                vb->pfns[vb->num_pfns] = page_to_balloon_pfn(page);
 
116
                totalram_pages--;
 
117
                vb->num_pages++;
 
118
                list_add(&page->lru, &vb->pages);
 
119
        }
 
120
 
 
121
        /* Didn't get any?  Oh well. */
 
122
        if (vb->num_pfns == 0)
 
123
                return;
 
124
 
 
125
        tell_host(vb, vb->inflate_vq);
 
126
}
 
127
 
 
128
static void release_pages_by_pfn(const u32 pfns[], unsigned int num)
 
129
{
 
130
        unsigned int i;
 
131
 
 
132
        for (i = 0; i < num; i++) {
 
133
                __free_page(pfn_to_page(pfns[i]));
 
134
                totalram_pages++;
 
135
        }
 
136
}
 
137
 
 
138
static void leak_balloon(struct virtio_balloon *vb, size_t num)
 
139
{
 
140
        struct page *page;
 
141
 
 
142
        /* We can only do one array worth at a time. */
 
143
        num = min(num, ARRAY_SIZE(vb->pfns));
 
144
 
 
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);
 
149
                vb->num_pages--;
 
150
        }
 
151
 
 
152
 
 
153
        /*
 
154
         * Note that if
 
155
         * virtio_has_feature(vdev, VIRTIO_BALLOON_F_MUST_TELL_HOST);
 
156
         * is true, we *have* to do it in this order
 
157
         */
 
158
        tell_host(vb, vb->deflate_vq);
 
159
        release_pages_by_pfn(vb->pfns, vb->num_pfns);
 
160
}
 
161
 
 
162
static inline void update_stat(struct virtio_balloon *vb, int idx,
 
163
                               u16 tag, u64 val)
 
164
{
 
165
        BUG_ON(idx >= VIRTIO_BALLOON_S_NR);
 
166
        vb->stats[idx].tag = tag;
 
167
        vb->stats[idx].val = val;
 
168
}
 
169
 
 
170
#define pages_to_bytes(x) ((u64)(x) << PAGE_SHIFT)
 
171
 
 
172
static void update_balloon_stats(struct virtio_balloon *vb)
 
173
{
 
174
        unsigned long events[NR_VM_EVENT_ITEMS];
 
175
        struct sysinfo i;
 
176
        int idx = 0;
 
177
 
 
178
        all_vm_events(events);
 
179
        si_meminfo(&i);
 
180
 
 
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));
 
191
}
 
192
 
 
193
/*
 
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().
 
200
 */
 
201
static void stats_request(struct virtqueue *vq)
 
202
{
 
203
        struct virtio_balloon *vb;
 
204
        unsigned int len;
 
205
 
 
206
        vb = virtqueue_get_buf(vq, &len);
 
207
        if (!vb)
 
208
                return;
 
209
        vb->need_stats_update = 1;
 
210
        wake_up(&vb->config_change);
 
211
}
 
212
 
 
213
static void stats_handle_request(struct virtio_balloon *vb)
 
214
{
 
215
        struct virtqueue *vq;
 
216
        struct scatterlist sg;
 
217
 
 
218
        vb->need_stats_update = 0;
 
219
        update_balloon_stats(vb);
 
220
 
 
221
        vq = vb->stats_vq;
 
222
        sg_init_one(&sg, vb->stats, sizeof(vb->stats));
 
223
        if (virtqueue_add_buf(vq, &sg, 1, 0, vb) < 0)
 
224
                BUG();
 
225
        virtqueue_kick(vq);
 
226
}
 
227
 
 
228
static void virtballoon_changed(struct virtio_device *vdev)
 
229
{
 
230
        struct virtio_balloon *vb = vdev->priv;
 
231
 
 
232
        wake_up(&vb->config_change);
 
233
}
 
234
 
 
235
static inline s64 towards_target(struct virtio_balloon *vb)
 
236
{
 
237
        u32 v;
 
238
        vb->vdev->config->get(vb->vdev,
 
239
                              offsetof(struct virtio_balloon_config, num_pages),
 
240
                              &v, sizeof(v));
 
241
        return (s64)v - vb->num_pages;
 
242
}
 
243
 
 
244
static void update_balloon_size(struct virtio_balloon *vb)
 
245
{
 
246
        __le32 actual = cpu_to_le32(vb->num_pages);
 
247
 
 
248
        vb->vdev->config->set(vb->vdev,
 
249
                              offsetof(struct virtio_balloon_config, actual),
 
250
                              &actual, sizeof(actual));
 
251
}
 
252
 
 
253
static int balloon(void *_vballoon)
 
254
{
 
255
        struct virtio_balloon *vb = _vballoon;
 
256
 
 
257
        set_freezable();
 
258
        while (!kthread_should_stop()) {
 
259
                s64 diff;
 
260
 
 
261
                try_to_freeze();
 
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);
 
269
                if (diff > 0)
 
270
                        fill_balloon(vb, diff);
 
271
                else if (diff < 0)
 
272
                        leak_balloon(vb, -diff);
 
273
                update_balloon_size(vb);
 
274
        }
 
275
        return 0;
 
276
}
 
277
 
 
278
static int virtballoon_probe(struct virtio_device *vdev)
 
279
{
 
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" };
 
284
        int err, nvqs;
 
285
 
 
286
        vdev->priv = vb = kmalloc(sizeof(*vb), GFP_KERNEL);
 
287
        if (!vb) {
 
288
                err = -ENOMEM;
 
289
                goto out;
 
290
        }
 
291
 
 
292
        INIT_LIST_HEAD(&vb->pages);
 
293
        vb->num_pages = 0;
 
294
        init_waitqueue_head(&vb->config_change);
 
295
        vb->vdev = vdev;
 
296
        vb->need_stats_update = 0;
 
297
 
 
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);
 
302
        if (err)
 
303
                goto out_free_vb;
 
304
 
 
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];
 
310
 
 
311
                /*
 
312
                 * Prime this virtqueue with one buffer so the hypervisor can
 
313
                 * use it to signal us later.
 
314
                 */
 
315
                sg_init_one(&sg, vb->stats, sizeof vb->stats);
 
316
                if (virtqueue_add_buf(vb->stats_vq, &sg, 1, 0, vb) < 0)
 
317
                        BUG();
 
318
                virtqueue_kick(vb->stats_vq);
 
319
        }
 
320
 
 
321
        vb->thread = kthread_run(balloon, vb, "vballoon");
 
322
        if (IS_ERR(vb->thread)) {
 
323
                err = PTR_ERR(vb->thread);
 
324
                goto out_del_vqs;
 
325
        }
 
326
 
 
327
        return 0;
 
328
 
 
329
out_del_vqs:
 
330
        vdev->config->del_vqs(vdev);
 
331
out_free_vb:
 
332
        kfree(vb);
 
333
out:
 
334
        return err;
 
335
}
 
336
 
 
337
static void __devexit virtballoon_remove(struct virtio_device *vdev)
 
338
{
 
339
        struct virtio_balloon *vb = vdev->priv;
 
340
 
 
341
        kthread_stop(vb->thread);
 
342
 
 
343
        /* There might be pages left in the balloon: free them. */
 
344
        while (vb->num_pages)
 
345
                leak_balloon(vb, vb->num_pages);
 
346
 
 
347
        /* Now we reset the device so we can clean up the queues. */
 
348
        vdev->config->reset(vdev);
 
349
 
 
350
        vdev->config->del_vqs(vdev);
 
351
        kfree(vb);
 
352
}
 
353
 
 
354
static unsigned int features[] = {
 
355
        VIRTIO_BALLOON_F_MUST_TELL_HOST,
 
356
        VIRTIO_BALLOON_F_STATS_VQ,
 
357
};
 
358
 
 
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,
 
368
};
 
369
 
 
370
static int __init init(void)
 
371
{
 
372
        return register_virtio_driver(&virtio_balloon_driver);
 
373
}
 
374
 
 
375
static void __exit fini(void)
 
376
{
 
377
        unregister_virtio_driver(&virtio_balloon_driver);
 
378
}
 
379
module_init(init);
 
380
module_exit(fini);
 
381
 
 
382
MODULE_DEVICE_TABLE(virtio, id_table);
 
383
MODULE_DESCRIPTION("Virtio balloon driver");
 
384
MODULE_LICENSE("GPL");