virtio_balloon.c 17.7 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
#include <linux/virtio.h>
#include <linux/virtio_balloon.h>
#include <linux/swap.h>
25
#include <linux/workqueue.h>
26
#include <linux/delay.h>
27
#include <linux/slab.h>
28
#include <linux/module.h>
29
#include <linux/balloon_compaction.h>
30
#include <linux/oom.h>
31
#include <linux/wait.h>
32
#include <linux/mm.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
	/* The balloon servicing is delegated to a freezable workqueue. */
53 54
	struct work_struct update_balloon_stats_work;
	struct work_struct update_balloon_size_work;
R
Rusty Russell 已提交
55

56 57 58
	/* Prevent updating balloon when it is being canceled. */
	spinlock_t stop_update_lock;
	bool stop_update;
R
Rusty Russell 已提交
59 60

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

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

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

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

	/* Memory statistics */
	struct virtio_balloon_stat stats[VIRTIO_BALLOON_S_NR];
82 83 84

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

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

92 93 94 95 96 97
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. */
98 99 100 101 102 103 104
	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);
105 106
}

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

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

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

	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. */
122
	virtqueue_add_outbuf(vq, &sg, 1, vb, GFP_KERNEL);
123
	virtqueue_kick(vq);
R
Rusty Russell 已提交
124 125

	/* When host has read buffer, this completes via balloon_ack */
126
	wait_event(vb->acked, virtqueue_get_buf(vq, &len));
127

R
Rusty Russell 已提交
128 129
}

130 131 132 133 134 135 136 137 138 139
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;
}

140
static unsigned fill_balloon(struct virtio_balloon *vb, size_t num)
R
Rusty Russell 已提交
141
{
142
	struct balloon_dev_info *vb_dev_info = &vb->vb_dev_info;
143
	unsigned num_allocated_pages;
144

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

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

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

168
	num_allocated_pages = vb->num_pfns;
169 170 171 172
	/* Did we get any? */
	if (vb->num_pfns != 0)
		tell_host(vb, vb->inflate_vq);
	mutex_unlock(&vb->balloon_lock);
173 174

	return num_allocated_pages;
R
Rusty Russell 已提交
175 176
}

177
static void release_pages_balloon(struct virtio_balloon *vb)
R
Rusty Russell 已提交
178 179 180
{
	unsigned int i;

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

191
static unsigned leak_balloon(struct virtio_balloon *vb, size_t num)
R
Rusty Russell 已提交
192
{
193
	unsigned num_freed_pages;
R
Rusty Russell 已提交
194
	struct page *page;
195
	struct balloon_dev_info *vb_dev_info = &vb->vb_dev_info;
R
Rusty Russell 已提交
196 197 198 199

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

200
	mutex_lock(&vb->balloon_lock);
201 202
	for (vb->num_pfns = 0; vb->num_pfns < num;
	     vb->num_pfns += VIRTIO_BALLOON_PAGES_PER_PAGE) {
203 204 205
		page = balloon_page_dequeue(vb_dev_info);
		if (!page)
			break;
206 207
		set_page_pfns(vb->pfns + vb->num_pfns, page);
		vb->num_pages -= VIRTIO_BALLOON_PAGES_PER_PAGE;
R
Rusty Russell 已提交
208 209
	}

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

223 224 225 226
static inline void update_stat(struct virtio_balloon *vb, int idx,
			       u16 tag, u64 val)
{
	BUG_ON(idx >= VIRTIO_BALLOON_S_NR);
227 228
	vb->stats[idx].tag = cpu_to_virtio16(vb->vdev, tag);
	vb->stats[idx].val = cpu_to_virtio64(vb->vdev, val);
229 230 231 232 233 234 235 236 237
}

#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;
238
	long available;
239 240 241 242

	all_vm_events(events);
	si_meminfo(&i);

243 244
	available = si_mem_available();

245 246 247 248 249 250 251 252 253 254
	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));
255 256
	update_stat(vb, idx++, VIRTIO_BALLOON_S_AVAIL,
				pages_to_bytes(available));
257 258 259 260 261 262 263
}

/*
 * 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
264
 * the virtqueue with a fresh stats buffer.  Since stats collection can sleep,
265 266
 * we delegate the job to a freezable workqueue that will do the actual work via
 * stats_handle_request().
267
 */
268
static void stats_request(struct virtqueue *vq)
269
{
270
	struct virtio_balloon *vb = vq->vdev->priv;
271

272 273
	spin_lock(&vb->stop_update_lock);
	if (!vb->stop_update)
274
		queue_work(system_freezable_wq, &vb->update_balloon_stats_work);
275
	spin_unlock(&vb->stop_update_lock);
276 277 278 279 280 281
}

static void stats_handle_request(struct virtio_balloon *vb)
{
	struct virtqueue *vq;
	struct scatterlist sg;
282
	unsigned int len;
283 284 285

	update_balloon_stats(vb);

286
	vq = vb->stats_vq;
287 288
	if (!virtqueue_get_buf(vq, &len))
		return;
289
	sg_init_one(&sg, vb->stats, sizeof(vb->stats));
290
	virtqueue_add_outbuf(vq, &sg, 1, vb, GFP_KERNEL);
291
	virtqueue_kick(vq);
292 293
}

R
Rusty Russell 已提交
294 295 296
static void virtballoon_changed(struct virtio_device *vdev)
{
	struct virtio_balloon *vb = vdev->priv;
297
	unsigned long flags;
R
Rusty Russell 已提交
298

299 300
	spin_lock_irqsave(&vb->stop_update_lock, flags);
	if (!vb->stop_update)
301
		queue_work(system_freezable_wq, &vb->update_balloon_size_work);
302
	spin_unlock_irqrestore(&vb->stop_update_lock, flags);
R
Rusty Russell 已提交
303 304
}

305
static inline s64 towards_target(struct virtio_balloon *vb)
R
Rusty Russell 已提交
306
{
D
David Gibson 已提交
307
	s64 target;
308
	u32 num_pages;
D
David Gibson 已提交
309

310 311
	virtio_cread(vb->vdev, struct virtio_balloon_config, num_pages,
		     &num_pages);
312

313 314 315 316 317
	/* 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 已提交
318
	return target - vb->num_pages;
R
Rusty Russell 已提交
319 320 321 322
}

static void update_balloon_size(struct virtio_balloon *vb)
{
323 324 325 326 327
	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 已提交
328

329
	virtio_cwrite(vb->vdev, struct virtio_balloon_config, actual,
330
		      &actual);
R
Rusty Russell 已提交
331 332
}

333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364
/*
 * 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;
}

365
static void update_balloon_stats_func(struct work_struct *work)
R
Rusty Russell 已提交
366
{
367
	struct virtio_balloon *vb;
368

369 370 371 372
	vb = container_of(work, struct virtio_balloon,
			  update_balloon_stats_work);
	stats_handle_request(vb);
}
373

374
static void update_balloon_size_func(struct work_struct *work)
R
Rusty Russell 已提交
375
{
376 377
	struct virtio_balloon *vb;
	s64 diff;
378

379 380
	vb = container_of(work, struct virtio_balloon,
			  update_balloon_size_work);
381
	diff = towards_target(vb);
382

383 384 385 386 387 388 389 390
	if (diff > 0)
		diff -= fill_balloon(vb, diff);
	else if (diff < 0)
		diff += leak_balloon(vb, -diff);
	update_balloon_size(vb);

	if (diff)
		queue_work(system_freezable_wq, work);
R
Rusty Russell 已提交
391 392
}

393
static int init_vqs(struct virtio_balloon *vb)
R
Rusty Russell 已提交
394
{
395
	struct virtqueue *vqs[3];
396
	vq_callback_t *callbacks[] = { balloon_ack, balloon_ack, stats_request };
397
	static const char * const names[] = { "inflate", "deflate", "stats" };
398
	int err, nvqs;
R
Rusty Russell 已提交
399

400 401 402 403
	/*
	 * We expect two virtqueues: inflate and deflate, and
	 * optionally stat.
	 */
404
	nvqs = virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ) ? 3 : 2;
405
	err = vb->vdev->config->find_vqs(vb->vdev, nvqs, vqs, callbacks, names);
406
	if (err)
407
		return err;
R
Rusty Russell 已提交
408

409 410
	vb->inflate_vq = vqs[0];
	vb->deflate_vq = vqs[1];
411 412 413 414 415 416
	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
417
		 * use it to signal us later (it can't be broken yet!).
418 419
		 */
		sg_init_one(&sg, vb->stats, sizeof vb->stats);
420
		if (virtqueue_add_outbuf(vb->stats_vq, &sg, 1, vb, GFP_KERNEL)
421
		    < 0)
422
			BUG();
423
		virtqueue_kick(vb->stats_vq);
424
	}
425 426 427
	return 0;
}

428 429 430 431
#ifdef CONFIG_BALLOON_COMPACTION
/*
 * virtballoon_migratepage - perform the balloon page migration on behalf of
 *			     a compation thread.     (called under page lock)
432
 * @vb_dev_info: the balloon device
433 434 435 436 437 438 439 440 441 442 443 444 445 446
 * @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
 */
447
static int virtballoon_migratepage(struct balloon_dev_info *vb_dev_info,
448 449
		struct page *newpage, struct page *page, enum migrate_mode mode)
{
450 451
	struct virtio_balloon *vb = container_of(vb_dev_info,
			struct virtio_balloon, vb_dev_info);
452 453 454 455 456 457 458 459 460 461 462 463 464
	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;

465 466
	get_page(newpage); /* balloon reference */

467 468
	/* balloon's page migration 1st step  -- inflate "newpage" */
	spin_lock_irqsave(&vb_dev_info->pages_lock, flags);
469
	balloon_page_insert(vb_dev_info, newpage);
470
	vb_dev_info->isolated_pages--;
471
	__count_vm_event(BALLOON_MIGRATE);
472 473 474 475 476
	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);

477
	/* balloon's page migration 2nd step -- deflate "page" */
478 479 480 481 482 483 484
	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);

485 486 487
	put_page(page); /* balloon reference */

	return MIGRATEPAGE_SUCCESS;
488 489 490
}
#endif /* CONFIG_BALLOON_COMPACTION */

491 492 493 494 495
static int virtballoon_probe(struct virtio_device *vdev)
{
	struct virtio_balloon *vb;
	int err;

496 497 498 499 500 501
	if (!vdev->config->get) {
		dev_err(&vdev->dev, "%s failure: config access disabled\n",
			__func__);
		return -EINVAL;
	}

502 503 504 505 506 507
	vdev->priv = vb = kmalloc(sizeof(*vb), GFP_KERNEL);
	if (!vb) {
		err = -ENOMEM;
		goto out;
	}

508 509
	INIT_WORK(&vb->update_balloon_stats_work, update_balloon_stats_func);
	INIT_WORK(&vb->update_balloon_size_work, update_balloon_size_func);
510 511
	spin_lock_init(&vb->stop_update_lock);
	vb->stop_update = false;
512
	vb->num_pages = 0;
513
	mutex_init(&vb->balloon_lock);
514
	init_waitqueue_head(&vb->acked);
515 516
	vb->vdev = vdev;

517 518 519 520
	balloon_devinfo_init(&vb->vb_dev_info);
#ifdef CONFIG_BALLOON_COMPACTION
	vb->vb_dev_info.migratepage = virtballoon_migratepage;
#endif
521

522 523
	err = init_vqs(vb);
	if (err)
524
		goto out_free_vb;
R
Rusty Russell 已提交
525

526 527 528 529 530 531
	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;

532 533
	virtio_device_ready(vdev);

R
Rusty Russell 已提交
534 535
	return 0;

536
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 564 565

	spin_lock_irq(&vb->stop_update_lock);
	vb->stop_update = true;
	spin_unlock_irq(&vb->stop_update_lock);
566 567
	cancel_work_sync(&vb->update_balloon_size_work);
	cancel_work_sync(&vb->update_balloon_stats_work);
568

569
	remove_common(vb);
R
Rusty Russell 已提交
570 571 572
	kfree(vb);
}

573
#ifdef CONFIG_PM_SLEEP
574 575
static int virtballoon_freeze(struct virtio_device *vdev)
{
576 577
	struct virtio_balloon *vb = vdev->priv;

578
	/*
579
	 * The workqueue is already frozen by the PM core before this
580 581
	 * function is called.
	 */
582
	remove_common(vb);
583 584 585
	return 0;
}

586
static int virtballoon_restore(struct virtio_device *vdev)
587 588 589 590 591 592 593 594
{
	struct virtio_balloon *vb = vdev->priv;
	int ret;

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

595 596
	virtio_device_ready(vdev);

597 598
	if (towards_target(vb))
		virtballoon_changed(vdev);
599 600 601
	update_balloon_size(vb);
	return 0;
}
602 603
#endif

604 605 606
static unsigned int features[] = {
	VIRTIO_BALLOON_F_MUST_TELL_HOST,
	VIRTIO_BALLOON_F_STATS_VQ,
607
	VIRTIO_BALLOON_F_DEFLATE_ON_OOM,
608
};
609

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

625
module_virtio_driver(virtio_balloon_driver);
R
Rusty Russell 已提交
626 627 628
MODULE_DEVICE_TABLE(virtio, id_table);
MODULE_DESCRIPTION("Virtio balloon driver");
MODULE_LICENSE("GPL");