virtio_balloon.c 17.8 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
	__virtio32 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
static void set_page_pfns(struct virtio_balloon *vb,
			  __virtio32 pfns[], struct page *page)
132 133 134 135 136 137
{
	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++)
138 139
		pfns[i] = cpu_to_virtio32(vb->vdev,
					  page_to_balloon_pfn(page) + i);
140 141
}

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

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

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

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

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

	return num_allocated_pages;
R
Rusty Russell 已提交
177 178
}

179
static void release_pages_balloon(struct virtio_balloon *vb)
R
Rusty Russell 已提交
180 181
{
	unsigned int i;
182
	struct page *page;
R
Rusty Russell 已提交
183

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

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

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

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

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

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

#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;
242
	long available;
243 244 245 246

	all_vm_events(events);
	si_meminfo(&i);

247 248
	available = si_mem_available();

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

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

276 277
	spin_lock(&vb->stop_update_lock);
	if (!vb->stop_update)
278
		queue_work(system_freezable_wq, &vb->update_balloon_stats_work);
279
	spin_unlock(&vb->stop_update_lock);
280 281 282 283 284 285
}

static void stats_handle_request(struct virtio_balloon *vb)
{
	struct virtqueue *vq;
	struct scatterlist sg;
286
	unsigned int len;
287 288 289

	update_balloon_stats(vb);

290
	vq = vb->stats_vq;
291 292
	if (!virtqueue_get_buf(vq, &len))
		return;
293
	sg_init_one(&sg, vb->stats, sizeof(vb->stats));
294
	virtqueue_add_outbuf(vq, &sg, 1, vb, GFP_KERNEL);
295
	virtqueue_kick(vq);
296 297
}

R
Rusty Russell 已提交
298 299 300
static void virtballoon_changed(struct virtio_device *vdev)
{
	struct virtio_balloon *vb = vdev->priv;
301
	unsigned long flags;
R
Rusty Russell 已提交
302

303 304
	spin_lock_irqsave(&vb->stop_update_lock, flags);
	if (!vb->stop_update)
305
		queue_work(system_freezable_wq, &vb->update_balloon_size_work);
306
	spin_unlock_irqrestore(&vb->stop_update_lock, flags);
R
Rusty Russell 已提交
307 308
}

309
static inline s64 towards_target(struct virtio_balloon *vb)
R
Rusty Russell 已提交
310
{
D
David Gibson 已提交
311
	s64 target;
312
	u32 num_pages;
D
David Gibson 已提交
313

314 315
	virtio_cread(vb->vdev, struct virtio_balloon_config, num_pages,
		     &num_pages);
316

317 318 319 320 321
	/* 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 已提交
322
	return target - vb->num_pages;
R
Rusty Russell 已提交
323 324 325 326
}

static void update_balloon_size(struct virtio_balloon *vb)
{
327 328 329 330 331
	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 已提交
332

333
	virtio_cwrite(vb->vdev, struct virtio_balloon_config, actual,
334
		      &actual);
R
Rusty Russell 已提交
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 365 366 367 368
/*
 * 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;
}

369
static void update_balloon_stats_func(struct work_struct *work)
R
Rusty Russell 已提交
370
{
371
	struct virtio_balloon *vb;
372

373 374 375 376
	vb = container_of(work, struct virtio_balloon,
			  update_balloon_stats_work);
	stats_handle_request(vb);
}
377

378
static void update_balloon_size_func(struct work_struct *work)
R
Rusty Russell 已提交
379
{
380 381
	struct virtio_balloon *vb;
	s64 diff;
382

383 384
	vb = container_of(work, struct virtio_balloon,
			  update_balloon_size_work);
385
	diff = towards_target(vb);
386

387 388 389 390 391 392 393 394
	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 已提交
395 396
}

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

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

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

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

469 470
	get_page(newpage); /* balloon reference */

471 472
	/* balloon's page migration 1st step  -- inflate "newpage" */
	spin_lock_irqsave(&vb_dev_info->pages_lock, flags);
473
	balloon_page_insert(vb_dev_info, newpage);
474
	vb_dev_info->isolated_pages--;
475
	__count_vm_event(BALLOON_MIGRATE);
476 477
	spin_unlock_irqrestore(&vb_dev_info->pages_lock, flags);
	vb->num_pfns = VIRTIO_BALLOON_PAGES_PER_PAGE;
478
	set_page_pfns(vb, vb->pfns, newpage);
479 480
	tell_host(vb, vb->inflate_vq);

481
	/* balloon's page migration 2nd step -- deflate "page" */
482 483
	balloon_page_delete(page);
	vb->num_pfns = VIRTIO_BALLOON_PAGES_PER_PAGE;
484
	set_page_pfns(vb, vb->pfns, page);
485 486 487 488
	tell_host(vb, vb->deflate_vq);

	mutex_unlock(&vb->balloon_lock);

489 490 491
	put_page(page); /* balloon reference */

	return MIGRATEPAGE_SUCCESS;
492 493 494
}
#endif /* CONFIG_BALLOON_COMPACTION */

495 496 497 498 499
static int virtballoon_probe(struct virtio_device *vdev)
{
	struct virtio_balloon *vb;
	int err;

500 501 502 503 504 505
	if (!vdev->config->get) {
		dev_err(&vdev->dev, "%s failure: config access disabled\n",
			__func__);
		return -EINVAL;
	}

506 507 508 509 510 511
	vdev->priv = vb = kmalloc(sizeof(*vb), GFP_KERNEL);
	if (!vb) {
		err = -ENOMEM;
		goto out;
	}

512 513
	INIT_WORK(&vb->update_balloon_stats_work, update_balloon_stats_func);
	INIT_WORK(&vb->update_balloon_size_work, update_balloon_size_func);
514 515
	spin_lock_init(&vb->stop_update_lock);
	vb->stop_update = false;
516
	vb->num_pages = 0;
517
	mutex_init(&vb->balloon_lock);
518
	init_waitqueue_head(&vb->acked);
519 520
	vb->vdev = vdev;

521 522 523 524
	balloon_devinfo_init(&vb->vb_dev_info);
#ifdef CONFIG_BALLOON_COMPACTION
	vb->vb_dev_info.migratepage = virtballoon_migratepage;
#endif
525

526 527
	err = init_vqs(vb);
	if (err)
528
		goto out_free_vb;
R
Rusty Russell 已提交
529

530 531 532 533 534 535
	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;

536 537
	virtio_device_ready(vdev);

R
Rusty Russell 已提交
538 539
	return 0;

540
out_oom_notify:
541
	vdev->config->del_vqs(vdev);
R
Rusty Russell 已提交
542 543 544 545 546 547
out_free_vb:
	kfree(vb);
out:
	return err;
}

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

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

558 559 560
	vb->vdev->config->del_vqs(vb->vdev);
}

561
static void virtballoon_remove(struct virtio_device *vdev)
562 563 564
{
	struct virtio_balloon *vb = vdev->priv;

565
	unregister_oom_notifier(&vb->nb);
566 567 568 569

	spin_lock_irq(&vb->stop_update_lock);
	vb->stop_update = true;
	spin_unlock_irq(&vb->stop_update_lock);
570 571
	cancel_work_sync(&vb->update_balloon_size_work);
	cancel_work_sync(&vb->update_balloon_stats_work);
572

573
	remove_common(vb);
R
Rusty Russell 已提交
574 575 576
	kfree(vb);
}

577
#ifdef CONFIG_PM_SLEEP
578 579
static int virtballoon_freeze(struct virtio_device *vdev)
{
580 581
	struct virtio_balloon *vb = vdev->priv;

582
	/*
583
	 * The workqueue is already frozen by the PM core before this
584 585
	 * function is called.
	 */
586
	remove_common(vb);
587 588 589
	return 0;
}

590
static int virtballoon_restore(struct virtio_device *vdev)
591 592 593 594 595 596 597 598
{
	struct virtio_balloon *vb = vdev->priv;
	int ret;

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

599 600
	virtio_device_ready(vdev);

601 602
	if (towards_target(vb))
		virtballoon_changed(vdev);
603 604 605
	update_balloon_size(vb);
	return 0;
}
606 607
#endif

608 609 610
static unsigned int features[] = {
	VIRTIO_BALLOON_F_MUST_TELL_HOST,
	VIRTIO_BALLOON_F_STATS_VQ,
611
	VIRTIO_BALLOON_F_DEFLATE_ON_OOM,
612
};
613

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

629
module_virtio_driver(virtio_balloon_driver);
R
Rusty Russell 已提交
630 631 632
MODULE_DEVICE_TABLE(virtio, id_table);
MODULE_DESCRIPTION("Virtio balloon driver");
MODULE_LICENSE("GPL");