virtio_balloon.c 17.2 KB
Newer Older
S
Sasha Levin 已提交
1 2
/*
 * Virtio balloon implementation, inspired by Dor Laor and Marcelo
R
Rusty Russell 已提交
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
 * Tosatti's implementations.
 *
 *  Copyright 2008 Rusty Russell IBM Corporation
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
S
Sasha Levin 已提交
21

R
Rusty Russell 已提交
22 23 24 25 26
#include <linux/virtio.h>
#include <linux/virtio_balloon.h>
#include <linux/swap.h>
#include <linux/kthread.h>
#include <linux/freezer.h>
27
#include <linux/delay.h>
28
#include <linux/slab.h>
29
#include <linux/module.h>
30
#include <linux/balloon_compaction.h>
31
#include <linux/oom.h>
32
#include <linux/wait.h>
R
Rusty Russell 已提交
33

34 35 36 37 38
/*
 * Balloon device works in 4K page units.  So each page is pointed to by
 * multiple balloon pages.  All memory counters in this driver are in balloon
 * page units.
 */
39 40
#define VIRTIO_BALLOON_PAGES_PER_PAGE (unsigned)(PAGE_SIZE >> VIRTIO_BALLOON_PFN_SHIFT)
#define VIRTIO_BALLOON_ARRAY_PFNS_MAX 256
41 42 43 44 45 46
#define OOM_VBALLOON_DEFAULT_PAGES 256
#define VIRTBALLOON_OOM_NOTIFY_PRIORITY 80

static int oom_pages = OOM_VBALLOON_DEFAULT_PAGES;
module_param(oom_pages, int, S_IRUSR | S_IWUSR);
MODULE_PARM_DESC(oom_pages, "pages to free on OOM");
47

48
struct virtio_balloon {
R
Rusty Russell 已提交
49
	struct virtio_device *vdev;
50
	struct virtqueue *inflate_vq, *deflate_vq, *stats_vq;
R
Rusty Russell 已提交
51 52 53 54 55 56 57 58

	/* Where the ballooning thread waits for config to change. */
	wait_queue_head_t config_change;

	/* The thread servicing the balloon. */
	struct task_struct *thread;

	/* Waiting for host to ack the pages we released. */
59
	wait_queue_head_t acked;
R
Rusty Russell 已提交
60

61
	/* Number of balloon pages we've told the Host we're not using. */
R
Rusty Russell 已提交
62
	unsigned int num_pages;
63
	/*
64 65
	 * The pages we've told the Host we're not using are enqueued
	 * at vb_dev_info->pages list.
66 67 68
	 * Each page on this list adds VIRTIO_BALLOON_PAGES_PER_PAGE
	 * to num_pages above.
	 */
69
	struct balloon_dev_info vb_dev_info;
70 71 72

	/* Synchronize access/update to this struct virtio_balloon elements */
	struct mutex balloon_lock;
R
Rusty Russell 已提交
73 74 75

	/* The array of pfns we tell the Host about. */
	unsigned int num_pfns;
76
	u32 pfns[VIRTIO_BALLOON_ARRAY_PFNS_MAX];
77 78

	/* Memory statistics */
79
	int need_stats_update;
80
	struct virtio_balloon_stat stats[VIRTIO_BALLOON_S_NR];
81 82 83

	/* To register callback in oom notifier call chain */
	struct notifier_block nb;
R
Rusty Russell 已提交
84 85 86 87 88 89 90
};

static struct virtio_device_id id_table[] = {
	{ VIRTIO_ID_BALLOON, VIRTIO_DEV_ANY_ID },
	{ 0 },
};

91 92 93 94 95 96
static u32 page_to_balloon_pfn(struct page *page)
{
	unsigned long pfn = page_to_pfn(page);

	BUILD_BUG_ON(PAGE_SHIFT < VIRTIO_BALLOON_PFN_SHIFT);
	/* Convert pfn from Linux page size to balloon page size. */
97 98 99 100 101 102 103
	return pfn * VIRTIO_BALLOON_PAGES_PER_PAGE;
}

static struct page *balloon_pfn_to_page(u32 pfn)
{
	BUG_ON(pfn % VIRTIO_BALLOON_PAGES_PER_PAGE);
	return pfn_to_page(pfn / VIRTIO_BALLOON_PAGES_PER_PAGE);
104 105
}

R
Rusty Russell 已提交
106 107
static void balloon_ack(struct virtqueue *vq)
{
108
	struct virtio_balloon *vb = vq->vdev->priv;
R
Rusty Russell 已提交
109

110
	wake_up(&vb->acked);
R
Rusty Russell 已提交
111 112 113 114 115
}

static void tell_host(struct virtio_balloon *vb, struct virtqueue *vq)
{
	struct scatterlist sg;
116
	unsigned int len;
R
Rusty Russell 已提交
117 118 119 120

	sg_init_one(&sg, vb->pfns, sizeof(vb->pfns[0]) * vb->num_pfns);

	/* We should always be able to add one buffer to an empty queue. */
121
	virtqueue_add_outbuf(vq, &sg, 1, vb, GFP_KERNEL);
122
	virtqueue_kick(vq);
R
Rusty Russell 已提交
123 124

	/* When host has read buffer, this completes via balloon_ack */
125
	wait_event(vb->acked, virtqueue_get_buf(vq, &len));
R
Rusty Russell 已提交
126 127
}

128 129 130 131 132 133 134 135 136 137
static void set_page_pfns(u32 pfns[], struct page *page)
{
	unsigned int i;

	/* Set balloon pfns pointing at this page.
	 * Note that the first pfn points at start of the page. */
	for (i = 0; i < VIRTIO_BALLOON_PAGES_PER_PAGE; i++)
		pfns[i] = page_to_balloon_pfn(page) + i;
}

R
Rusty Russell 已提交
138 139
static void fill_balloon(struct virtio_balloon *vb, size_t num)
{
140
	struct balloon_dev_info *vb_dev_info = &vb->vb_dev_info;
141

R
Rusty Russell 已提交
142 143 144
	/* We can only do one array worth at a time. */
	num = min(num, ARRAY_SIZE(vb->pfns));

145
	mutex_lock(&vb->balloon_lock);
146 147
	for (vb->num_pfns = 0; vb->num_pfns < num;
	     vb->num_pfns += VIRTIO_BALLOON_PAGES_PER_PAGE) {
148 149
		struct page *page = balloon_page_enqueue(vb_dev_info);

R
Rusty Russell 已提交
150
		if (!page) {
151
			dev_info_ratelimited(&vb->vdev->dev,
152 153
					     "Out of puff! Can't get %u pages\n",
					     VIRTIO_BALLOON_PAGES_PER_PAGE);
R
Rusty Russell 已提交
154 155 156 157
			/* Sleep for at least 1/5 of a second before retry. */
			msleep(200);
			break;
		}
158 159
		set_page_pfns(vb->pfns + vb->num_pfns, page);
		vb->num_pages += VIRTIO_BALLOON_PAGES_PER_PAGE;
160 161 162
		if (!virtio_has_feature(vb->vdev,
					VIRTIO_BALLOON_F_DEFLATE_ON_OOM))
			adjust_managed_page_count(page, -1);
R
Rusty Russell 已提交
163 164
	}

165 166 167 168
	/* Did we get any? */
	if (vb->num_pfns != 0)
		tell_host(vb, vb->inflate_vq);
	mutex_unlock(&vb->balloon_lock);
R
Rusty Russell 已提交
169 170
}

171
static void release_pages_balloon(struct virtio_balloon *vb)
R
Rusty Russell 已提交
172 173 174
{
	unsigned int i;

175
	/* Find pfns pointing at start of each page, get pages and free them. */
176 177
	for (i = 0; i < vb->num_pfns; i += VIRTIO_BALLOON_PAGES_PER_PAGE) {
		struct page *page = balloon_pfn_to_page(vb->pfns[i]);
178 179 180
		if (!virtio_has_feature(vb->vdev,
					VIRTIO_BALLOON_F_DEFLATE_ON_OOM))
			adjust_managed_page_count(page, 1);
181
		put_page(page); /* balloon reference */
R
Rusty Russell 已提交
182 183 184
	}
}

185
static unsigned leak_balloon(struct virtio_balloon *vb, size_t num)
R
Rusty Russell 已提交
186
{
187
	unsigned num_freed_pages;
R
Rusty Russell 已提交
188
	struct page *page;
189
	struct balloon_dev_info *vb_dev_info = &vb->vb_dev_info;
R
Rusty Russell 已提交
190 191 192 193

	/* We can only do one array worth at a time. */
	num = min(num, ARRAY_SIZE(vb->pfns));

194
	mutex_lock(&vb->balloon_lock);
195 196
	for (vb->num_pfns = 0; vb->num_pfns < num;
	     vb->num_pfns += VIRTIO_BALLOON_PAGES_PER_PAGE) {
197 198 199
		page = balloon_page_dequeue(vb_dev_info);
		if (!page)
			break;
200 201
		set_page_pfns(vb->pfns + vb->num_pfns, page);
		vb->num_pages -= VIRTIO_BALLOON_PAGES_PER_PAGE;
R
Rusty Russell 已提交
202 203
	}

204
	num_freed_pages = vb->num_pfns;
205 206 207 208 209
	/*
	 * Note that if
	 * virtio_has_feature(vdev, VIRTIO_BALLOON_F_MUST_TELL_HOST);
	 * is true, we *have* to do it in this order
	 */
210 211
	if (vb->num_pfns != 0)
		tell_host(vb, vb->deflate_vq);
212
	release_pages_balloon(vb);
213
	mutex_unlock(&vb->balloon_lock);
214
	return num_freed_pages;
R
Rusty Russell 已提交
215 216
}

217 218 219 220
static inline void update_stat(struct virtio_balloon *vb, int idx,
			       u16 tag, u64 val)
{
	BUG_ON(idx >= VIRTIO_BALLOON_S_NR);
221 222
	vb->stats[idx].tag = cpu_to_virtio16(vb->vdev, tag);
	vb->stats[idx].val = cpu_to_virtio64(vb->vdev, val);
223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252
}

#define pages_to_bytes(x) ((u64)(x) << PAGE_SHIFT)

static void update_balloon_stats(struct virtio_balloon *vb)
{
	unsigned long events[NR_VM_EVENT_ITEMS];
	struct sysinfo i;
	int idx = 0;

	all_vm_events(events);
	si_meminfo(&i);

	update_stat(vb, idx++, VIRTIO_BALLOON_S_SWAP_IN,
				pages_to_bytes(events[PSWPIN]));
	update_stat(vb, idx++, VIRTIO_BALLOON_S_SWAP_OUT,
				pages_to_bytes(events[PSWPOUT]));
	update_stat(vb, idx++, VIRTIO_BALLOON_S_MAJFLT, events[PGMAJFAULT]);
	update_stat(vb, idx++, VIRTIO_BALLOON_S_MINFLT, events[PGFAULT]);
	update_stat(vb, idx++, VIRTIO_BALLOON_S_MEMFREE,
				pages_to_bytes(i.freeram));
	update_stat(vb, idx++, VIRTIO_BALLOON_S_MEMTOT,
				pages_to_bytes(i.totalram));
}

/*
 * While most virtqueues communicate guest-initiated requests to the hypervisor,
 * the stats queue operates in reverse.  The driver initializes the virtqueue
 * with a single buffer.  From that point forward, all conversations consist of
 * a hypervisor request (a call to this function) which directs us to refill
253 254
 * the virtqueue with a fresh stats buffer.  Since stats collection can sleep,
 * we notify our kthread which does the actual work via stats_handle_request().
255
 */
256
static void stats_request(struct virtqueue *vq)
257
{
258
	struct virtio_balloon *vb = vq->vdev->priv;
259

260 261 262 263 264 265 266 267
	vb->need_stats_update = 1;
	wake_up(&vb->config_change);
}

static void stats_handle_request(struct virtio_balloon *vb)
{
	struct virtqueue *vq;
	struct scatterlist sg;
268
	unsigned int len;
269

270
	vb->need_stats_update = 0;
271 272
	update_balloon_stats(vb);

273
	vq = vb->stats_vq;
274 275
	if (!virtqueue_get_buf(vq, &len))
		return;
276
	sg_init_one(&sg, vb->stats, sizeof(vb->stats));
277
	virtqueue_add_outbuf(vq, &sg, 1, vb, GFP_KERNEL);
278
	virtqueue_kick(vq);
279 280
}

R
Rusty Russell 已提交
281 282 283 284 285 286 287
static void virtballoon_changed(struct virtio_device *vdev)
{
	struct virtio_balloon *vb = vdev->priv;

	wake_up(&vb->config_change);
}

288
static inline s64 towards_target(struct virtio_balloon *vb)
R
Rusty Russell 已提交
289
{
D
David Gibson 已提交
290
	s64 target;
291
	u32 num_pages;
D
David Gibson 已提交
292

293 294
	virtio_cread(vb->vdev, struct virtio_balloon_config, num_pages,
		     &num_pages);
295

296 297 298 299 300
	/* Legacy balloon config space is LE, unlike all other devices. */
	if (!virtio_has_feature(vb->vdev, VIRTIO_F_VERSION_1))
		num_pages = le32_to_cpu((__force __le32)num_pages);

	target = num_pages;
D
David Gibson 已提交
301
	return target - vb->num_pages;
R
Rusty Russell 已提交
302 303 304 305
}

static void update_balloon_size(struct virtio_balloon *vb)
{
306 307 308 309 310
	u32 actual = vb->num_pages;

	/* Legacy balloon config space is LE, unlike all other devices. */
	if (!virtio_has_feature(vb->vdev, VIRTIO_F_VERSION_1))
		actual = (__force u32)cpu_to_le32(actual);
R
Rusty Russell 已提交
311

312
	virtio_cwrite(vb->vdev, struct virtio_balloon_config, actual,
313
		      &actual);
R
Rusty Russell 已提交
314 315
}

316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347
/*
 * virtballoon_oom_notify - release pages when system is under severe
 *			    memory pressure (called from out_of_memory())
 * @self : notifier block struct
 * @dummy: not used
 * @parm : returned - number of freed pages
 *
 * The balancing of memory by use of the virtio balloon should not cause
 * the termination of processes while there are pages in the balloon.
 * If virtio balloon manages to release some memory, it will make the
 * system return and retry the allocation that forced the OOM killer
 * to run.
 */
static int virtballoon_oom_notify(struct notifier_block *self,
				  unsigned long dummy, void *parm)
{
	struct virtio_balloon *vb;
	unsigned long *freed;
	unsigned num_freed_pages;

	vb = container_of(self, struct virtio_balloon, nb);
	if (!virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_DEFLATE_ON_OOM))
		return NOTIFY_OK;

	freed = parm;
	num_freed_pages = leak_balloon(vb, oom_pages);
	update_balloon_size(vb);
	*freed += num_freed_pages;

	return NOTIFY_OK;
}

R
Rusty Russell 已提交
348 349 350
static int balloon(void *_vballoon)
{
	struct virtio_balloon *vb = _vballoon;
351
	DEFINE_WAIT_FUNC(wait, woken_wake_function);
R
Rusty Russell 已提交
352 353 354

	set_freezable();
	while (!kthread_should_stop()) {
355
		s64 diff;
R
Rusty Russell 已提交
356 357

		try_to_freeze();
358 359 360 361 362 363 364 365 366 367 368 369

		add_wait_queue(&vb->config_change, &wait);
		for (;;) {
			if ((diff = towards_target(vb)) != 0 ||
			    vb->need_stats_update ||
			    kthread_should_stop() ||
			    freezing(current))
				break;
			wait_woken(&wait, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
		}
		remove_wait_queue(&vb->config_change, &wait);

370 371
		if (vb->need_stats_update)
			stats_handle_request(vb);
R
Rusty Russell 已提交
372 373 374 375 376
		if (diff > 0)
			fill_balloon(vb, diff);
		else if (diff < 0)
			leak_balloon(vb, -diff);
		update_balloon_size(vb);
377 378 379 380 381 382

		/*
		 * For large balloon changes, we could spend a lot of time
		 * and always have work to do.  Be nice if preempt disabled.
		 */
		cond_resched();
R
Rusty Russell 已提交
383 384 385 386
	}
	return 0;
}

387
static int init_vqs(struct virtio_balloon *vb)
R
Rusty Russell 已提交
388
{
389
	struct virtqueue *vqs[3];
390
	vq_callback_t *callbacks[] = { balloon_ack, balloon_ack, stats_request };
391 392
	const char *names[] = { "inflate", "deflate", "stats" };
	int err, nvqs;
R
Rusty Russell 已提交
393

394 395 396 397
	/*
	 * We expect two virtqueues: inflate and deflate, and
	 * optionally stat.
	 */
398
	nvqs = virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ) ? 3 : 2;
399
	err = vb->vdev->config->find_vqs(vb->vdev, nvqs, vqs, callbacks, names);
400
	if (err)
401
		return err;
R
Rusty Russell 已提交
402

403 404
	vb->inflate_vq = vqs[0];
	vb->deflate_vq = vqs[1];
405 406 407 408 409 410
	if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ)) {
		struct scatterlist sg;
		vb->stats_vq = vqs[2];

		/*
		 * Prime this virtqueue with one buffer so the hypervisor can
411
		 * use it to signal us later (it can't be broken yet!).
412 413
		 */
		sg_init_one(&sg, vb->stats, sizeof vb->stats);
414
		if (virtqueue_add_outbuf(vb->stats_vq, &sg, 1, vb, GFP_KERNEL)
415
		    < 0)
416
			BUG();
417
		virtqueue_kick(vb->stats_vq);
418
	}
419 420 421
	return 0;
}

422 423 424 425
#ifdef CONFIG_BALLOON_COMPACTION
/*
 * virtballoon_migratepage - perform the balloon page migration on behalf of
 *			     a compation thread.     (called under page lock)
426
 * @vb_dev_info: the balloon device
427 428 429 430 431 432 433 434 435 436 437 438 439 440
 * @newpage: page that will replace the isolated page after migration finishes.
 * @page   : the isolated (old) page that is about to be migrated to newpage.
 * @mode   : compaction mode -- not used for balloon page migration.
 *
 * After a ballooned page gets isolated by compaction procedures, this is the
 * function that performs the page migration on behalf of a compaction thread
 * The page migration for virtio balloon is done in a simple swap fashion which
 * follows these two macro steps:
 *  1) insert newpage into vb->pages list and update the host about it;
 *  2) update the host about the old page removed from vb->pages list;
 *
 * This function preforms the balloon page migration task.
 * Called through balloon_mapping->a_ops->migratepage
 */
441
static int virtballoon_migratepage(struct balloon_dev_info *vb_dev_info,
442 443
		struct page *newpage, struct page *page, enum migrate_mode mode)
{
444 445
	struct virtio_balloon *vb = container_of(vb_dev_info,
			struct virtio_balloon, vb_dev_info);
446 447 448 449 450 451 452 453 454 455 456 457 458
	unsigned long flags;

	/*
	 * In order to avoid lock contention while migrating pages concurrently
	 * to leak_balloon() or fill_balloon() we just give up the balloon_lock
	 * this turn, as it is easier to retry the page migration later.
	 * This also prevents fill_balloon() getting stuck into a mutex
	 * recursion in the case it ends up triggering memory compaction
	 * while it is attempting to inflate the ballon.
	 */
	if (!mutex_trylock(&vb->balloon_lock))
		return -EAGAIN;

459 460
	get_page(newpage); /* balloon reference */

461 462
	/* balloon's page migration 1st step  -- inflate "newpage" */
	spin_lock_irqsave(&vb_dev_info->pages_lock, flags);
463
	balloon_page_insert(vb_dev_info, newpage);
464
	vb_dev_info->isolated_pages--;
465
	__count_vm_event(BALLOON_MIGRATE);
466 467 468 469 470
	spin_unlock_irqrestore(&vb_dev_info->pages_lock, flags);
	vb->num_pfns = VIRTIO_BALLOON_PAGES_PER_PAGE;
	set_page_pfns(vb->pfns, newpage);
	tell_host(vb, vb->inflate_vq);

471
	/* balloon's page migration 2nd step -- deflate "page" */
472 473 474 475 476 477 478
	balloon_page_delete(page);
	vb->num_pfns = VIRTIO_BALLOON_PAGES_PER_PAGE;
	set_page_pfns(vb->pfns, page);
	tell_host(vb, vb->deflate_vq);

	mutex_unlock(&vb->balloon_lock);

479 480 481
	put_page(page); /* balloon reference */

	return MIGRATEPAGE_SUCCESS;
482 483 484
}
#endif /* CONFIG_BALLOON_COMPACTION */

485 486 487 488 489
static int virtballoon_probe(struct virtio_device *vdev)
{
	struct virtio_balloon *vb;
	int err;

490 491 492 493 494 495
	if (!vdev->config->get) {
		dev_err(&vdev->dev, "%s failure: config access disabled\n",
			__func__);
		return -EINVAL;
	}

496 497 498 499 500 501 502
	vdev->priv = vb = kmalloc(sizeof(*vb), GFP_KERNEL);
	if (!vb) {
		err = -ENOMEM;
		goto out;
	}

	vb->num_pages = 0;
503
	mutex_init(&vb->balloon_lock);
504
	init_waitqueue_head(&vb->config_change);
505
	init_waitqueue_head(&vb->acked);
506 507 508
	vb->vdev = vdev;
	vb->need_stats_update = 0;

509 510 511 512
	balloon_devinfo_init(&vb->vb_dev_info);
#ifdef CONFIG_BALLOON_COMPACTION
	vb->vb_dev_info.migratepage = virtballoon_migratepage;
#endif
513

514 515
	err = init_vqs(vb);
	if (err)
516
		goto out_free_vb;
R
Rusty Russell 已提交
517

518 519 520 521 522 523
	vb->nb.notifier_call = virtballoon_oom_notify;
	vb->nb.priority = VIRTBALLOON_OOM_NOTIFY_PRIORITY;
	err = register_oom_notifier(&vb->nb);
	if (err < 0)
		goto out_oom_notify;

524 525
	virtio_device_ready(vdev);

R
Rusty Russell 已提交
526 527 528
	vb->thread = kthread_run(balloon, vb, "vballoon");
	if (IS_ERR(vb->thread)) {
		err = PTR_ERR(vb->thread);
529
		goto out_del_vqs;
R
Rusty Russell 已提交
530 531 532 533
	}

	return 0;

534
out_del_vqs:
535 536
	unregister_oom_notifier(&vb->nb);
out_oom_notify:
537
	vdev->config->del_vqs(vdev);
R
Rusty Russell 已提交
538 539 540 541 542 543
out_free_vb:
	kfree(vb);
out:
	return err;
}

544
static void remove_common(struct virtio_balloon *vb)
R
Rusty Russell 已提交
545 546 547 548
{
	/* There might be pages left in the balloon: free them. */
	while (vb->num_pages)
		leak_balloon(vb, vb->num_pages);
549
	update_balloon_size(vb);
R
Rusty Russell 已提交
550 551

	/* Now we reset the device so we can clean up the queues. */
552
	vb->vdev->config->reset(vb->vdev);
R
Rusty Russell 已提交
553

554 555 556
	vb->vdev->config->del_vqs(vb->vdev);
}

557
static void virtballoon_remove(struct virtio_device *vdev)
558 559 560
{
	struct virtio_balloon *vb = vdev->priv;

561
	unregister_oom_notifier(&vb->nb);
562 563
	kthread_stop(vb->thread);
	remove_common(vb);
R
Rusty Russell 已提交
564 565 566
	kfree(vb);
}

567
#ifdef CONFIG_PM_SLEEP
568 569
static int virtballoon_freeze(struct virtio_device *vdev)
{
570 571
	struct virtio_balloon *vb = vdev->priv;

572 573 574 575 576
	/*
	 * The kthread is already frozen by the PM core before this
	 * function is called.
	 */

577
	remove_common(vb);
578 579 580
	return 0;
}

581
static int virtballoon_restore(struct virtio_device *vdev)
582 583 584 585 586 587 588 589
{
	struct virtio_balloon *vb = vdev->priv;
	int ret;

	ret = init_vqs(vdev->priv);
	if (ret)
		return ret;

590 591
	virtio_device_ready(vdev);

592 593 594 595
	fill_balloon(vb, towards_target(vb));
	update_balloon_size(vb);
	return 0;
}
596 597
#endif

598 599 600
static unsigned int features[] = {
	VIRTIO_BALLOON_F_MUST_TELL_HOST,
	VIRTIO_BALLOON_F_STATS_VQ,
601
	VIRTIO_BALLOON_F_DEFLATE_ON_OOM,
602
};
603

604
static struct virtio_driver virtio_balloon_driver = {
605 606
	.feature_table = features,
	.feature_table_size = ARRAY_SIZE(features),
R
Rusty Russell 已提交
607 608 609 610
	.driver.name =	KBUILD_MODNAME,
	.driver.owner =	THIS_MODULE,
	.id_table =	id_table,
	.probe =	virtballoon_probe,
611
	.remove =	virtballoon_remove,
R
Rusty Russell 已提交
612
	.config_changed = virtballoon_changed,
613
#ifdef CONFIG_PM_SLEEP
614 615 616
	.freeze	=	virtballoon_freeze,
	.restore =	virtballoon_restore,
#endif
R
Rusty Russell 已提交
617 618
};

619
module_virtio_driver(virtio_balloon_driver);
R
Rusty Russell 已提交
620 621 622
MODULE_DEVICE_TABLE(virtio, id_table);
MODULE_DESCRIPTION("Virtio balloon driver");
MODULE_LICENSE("GPL");