virtio_balloon: introduce migration primitives to balloon pages

Memory fragmentation introduced by ballooning might reduce significantly the number of 2MB contiguous memory blocks that can be used within a guest, thus imposing performance penalties associated with the reduced number of transparent huge pages that could be used by the guest workload. Besides making balloon pages movable at allocation time and introducing the necessary primitives to perform balloon page migration/compaction, this patch also introduces the following locking scheme, in order to enhance the syncronization methods for accessing elements of struct virtio_balloon, thus providing protection against concurrent access introduced by parallel memory migration threads. - balloon_lock (mutex) : synchronizes the access demand to elements of struct virtio_balloon and its queue operations; [yongjun_wei@trendmicro.com.cn: fix missing unlock on error in fill_balloon()] [akpm@linux-foundation.org: avoid having multiple return points in fill_balloon()] [akpm@linux-foundation.org: fix printk warning]Signed-off-by: Rafael Aquini <aquini@redhat.com> Acked-by: Michael S. Tsirkin <mst@redhat.com> Cc: Rusty Russell <rusty@rustcorp.com.au> Cc: Rik van Riel <riel@redhat.com> Cc: Mel Gorman <mel@csn.ul.ie> Cc: Andi Kleen <andi@firstfloor.org> Cc: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com> Cc: Minchan Kim <minchan@kernel.org> Signed-off-by: Wei Yongjun <yongjun_wei@trendmicro.com.cn> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

virtio_balloon: introduce migration primitives to balloon pages
Memory fragmentation introduced by ballooning might reduce significantly the number of 2MB contiguous memory blocks that can be used within a guest, thus imposing performance penalties associated with the reduced number of transparent huge pages that could be used by the guest workload. Besides making balloon pages movable at allocation time and introducing the necessary primitives to perform balloon page migration/compaction, this patch also introduces the following locking scheme, in order to enhance the syncronization methods for accessing elements of struct virtio_balloon, thus providing protection against concurrent access introduced by parallel memory migration threads. - balloon_lock (mutex) : synchronizes the access demand to elements of struct virtio_balloon and its queue operations; [yongjun_wei@trendmicro.com.cn: fix missing unlock on error in fill_balloon()] [akpm@linux-foundation.org: avoid having multiple return points in fill_balloon()] [akpm@linux-foundation.org: fix printk warning]Signed-off-by: Rafael Aquini <aquini@redhat.com> Acked-by: Michael S. Tsirkin <mst@redhat.com> Cc: Rusty Russell <rusty@rustcorp.com.au> Cc: Rik van Riel <riel@redhat.com> Cc: Mel Gorman <mel@csn.ul.ie> Cc: Andi Kleen <andi@firstfloor.org> Cc: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com> Cc: Minchan Kim <minchan@kernel.org> Signed-off-by: Wei Yongjun <yongjun_wei@trendmicro.com.cn> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Rafael Aquini · Linus Torvalds
1 parent bf6bddf192
Showing 1 changed file with 132 additions and 19 deletions Side-by-side Diff
drivers/virtio/virtio_balloon.c
@@ -27,13 +27,15 @@
 #include <linux/delay.h>
 #include <linux/slab.h>
 #include <linux/module.h>
+#include <linux/balloon_compaction.h>
  
 /*
  * 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.
  */
-#define VIRTIO_BALLOON_PAGES_PER_PAGE (PAGE_SIZE >> VIRTIO_BALLOON_PFN_SHIFT)
+#define VIRTIO_BALLOON_PAGES_PER_PAGE (unsigned)(PAGE_SIZE >> VIRTIO_BALLOON_PFN_SHIFT)
+#define VIRTIO_BALLOON_ARRAY_PFNS_MAX 256
  
 struct virtio_balloon
 {
  
  
  
@@ -52,15 +54,19 @@
 	/* Number of balloon pages we've told the Host we're not using. */
 	unsigned int num_pages;
 	/*
-	 * The pages we've told the Host we're not using.
+	 * The pages we've told the Host we're not using are enqueued
+	 * at vb_dev_info->pages list.
 	 * Each page on this list adds VIRTIO_BALLOON_PAGES_PER_PAGE
 	 * to num_pages above.
 	 */
-	struct list_head pages;
+	struct balloon_dev_info *vb_dev_info;
  
+	/* Synchronize access/update to this struct virtio_balloon elements */
+	struct mutex balloon_lock;
+
 	/* The array of pfns we tell the Host about. */
 	unsigned int num_pfns;
-	u32 pfns[256];
+	u32 pfns[VIRTIO_BALLOON_ARRAY_PFNS_MAX];
  
 	/* Memory statistics */
 	int need_stats_update;
  
  
  
@@ -122,18 +128,21 @@
  
 static void fill_balloon(struct virtio_balloon *vb, size_t num)
 {
+	struct balloon_dev_info *vb_dev_info = vb->vb_dev_info;
+
 	/* We can only do one array worth at a time. */
 	num = min(num, ARRAY_SIZE(vb->pfns));
  
+	mutex_lock(&vb->balloon_lock);
 	for (vb->num_pfns = 0; vb->num_pfns < num;
 	     vb->num_pfns += VIRTIO_BALLOON_PAGES_PER_PAGE) {
-		struct page *page = alloc_page(GFP_HIGHUSER | __GFP_NORETRY |
-					__GFP_NOMEMALLOC | __GFP_NOWARN);
+		struct page *page = balloon_page_enqueue(vb_dev_info);
+
 		if (!page) {
 			if (printk_ratelimit())
 				dev_printk(KERN_INFO, &vb->vdev->dev,
-					   "Out of puff! Can't get %zu pages\n",
-					   num);
+					   "Out of puff! Can't get %u pages\n",
+					   VIRTIO_BALLOON_PAGES_PER_PAGE);
 			/* Sleep for at least 1/5 of a second before retry. */
 			msleep(200);
 			break;
  
@@ -141,14 +150,12 @@
 		set_page_pfns(vb->pfns + vb->num_pfns, page);
 		vb->num_pages += VIRTIO_BALLOON_PAGES_PER_PAGE;
 		totalram_pages--;
-		list_add(&page->lru, &vb->pages);
 	}
  
-	/* Didn't get any?  Oh well. */
-	if (vb->num_pfns == 0)
-		return;
-
-	tell_host(vb, vb->inflate_vq);
+	/* Did we get any? */
+	if (vb->num_pfns != 0)
+		tell_host(vb, vb->inflate_vq);
+	mutex_unlock(&vb->balloon_lock);
 }
  
 static void release_pages_by_pfn(const u32 pfns[], unsigned int num)
@@ -157,7 +164,7 @@
  
 	/* Find pfns pointing at start of each page, get pages and free them. */
 	for (i = 0; i < num; i += VIRTIO_BALLOON_PAGES_PER_PAGE) {
-		__free_page(balloon_pfn_to_page(pfns[i]));
+		balloon_page_free(balloon_pfn_to_page(pfns[i]));
 		totalram_pages++;
 	}
 }
  
  
@@ -165,14 +172,17 @@
 static void leak_balloon(struct virtio_balloon *vb, size_t num)
 {
 	struct page *page;
+	struct balloon_dev_info *vb_dev_info = vb->vb_dev_info;
  
 	/* We can only do one array worth at a time. */
 	num = min(num, ARRAY_SIZE(vb->pfns));
  
+	mutex_lock(&vb->balloon_lock);
 	for (vb->num_pfns = 0; vb->num_pfns < num;
 	     vb->num_pfns += VIRTIO_BALLOON_PAGES_PER_PAGE) {
-		page = list_first_entry(&vb->pages, struct page, lru);
-		list_del(&page->lru);
+		page = balloon_page_dequeue(vb_dev_info);
+		if (!page)
+			break;
 		set_page_pfns(vb->pfns + vb->num_pfns, page);
 		vb->num_pages -= VIRTIO_BALLOON_PAGES_PER_PAGE;
 	}
@@ -183,6 +193,7 @@
 	 * is true, we *have* to do it in this order
 	 */
 	tell_host(vb, vb->deflate_vq);
+	mutex_unlock(&vb->balloon_lock);
 	release_pages_by_pfn(vb->pfns, vb->num_pfns);
 }
  
  
@@ -339,9 +350,84 @@
 	return 0;
 }
  
+static const struct address_space_operations virtio_balloon_aops;
+#ifdef CONFIG_BALLOON_COMPACTION
+/*
+ * virtballoon_migratepage - perform the balloon page migration on behalf of
+ *			     a compation thread.     (called under page lock)
+ * @mapping: the page->mapping which will be assigned to the new migrated page.
+ * @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
+ */
+int virtballoon_migratepage(struct address_space *mapping,
+		struct page *newpage, struct page *page, enum migrate_mode mode)
+{
+	struct balloon_dev_info *vb_dev_info = balloon_page_device(page);
+	struct virtio_balloon *vb;
+	unsigned long flags;
+
+	BUG_ON(!vb_dev_info);
+
+	vb = vb_dev_info->balloon_device;
+
+	/*
+	 * 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;
+
+	/* balloon's page migration 1st step  -- inflate "newpage" */
+	spin_lock_irqsave(&vb_dev_info->pages_lock, flags);
+	balloon_page_insert(newpage, mapping, &vb_dev_info->pages);
+	vb_dev_info->isolated_pages--;
+	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);
+
+	/*
+	 * balloon's page migration 2nd step -- deflate "page"
+	 *
+	 * It's safe to delete page->lru here because this page is at
+	 * an isolated migration list, and this step is expected to happen here
+	 */
+	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);
+
+	return MIGRATEPAGE_BALLOON_SUCCESS;
+}
+
+/* define the balloon_mapping->a_ops callback to allow balloon page migration */
+static const struct address_space_operations virtio_balloon_aops = {
+			.migratepage = virtballoon_migratepage,
+};
+#endif /* CONFIG_BALLOON_COMPACTION */
+
 static int virtballoon_probe(struct virtio_device *vdev)
 {
 	struct virtio_balloon *vb;
+	struct address_space *vb_mapping;
+	struct balloon_dev_info *vb_devinfo;
 	int err;
  
 	vdev->priv = vb = kmalloc(sizeof(*vb), GFP_KERNEL);
  
  
  
@@ -350,16 +436,37 @@
 		goto out;
 	}
  
-	INIT_LIST_HEAD(&vb->pages);
 	vb->num_pages = 0;
+	mutex_init(&vb->balloon_lock);
 	init_waitqueue_head(&vb->config_change);
 	init_waitqueue_head(&vb->acked);
 	vb->vdev = vdev;
 	vb->need_stats_update = 0;
  
+	vb_devinfo = balloon_devinfo_alloc(vb);
+	if (IS_ERR(vb_devinfo)) {
+		err = PTR_ERR(vb_devinfo);
+		goto out_free_vb;
+	}
+
+	vb_mapping = balloon_mapping_alloc(vb_devinfo,
+					   (balloon_compaction_check()) ?
+					   &virtio_balloon_aops : NULL);
+	if (IS_ERR(vb_mapping)) {
+		/*
+		 * IS_ERR(vb_mapping) && PTR_ERR(vb_mapping) == -EOPNOTSUPP
+		 * This means !CONFIG_BALLOON_COMPACTION, otherwise we get off.
+		 */
+		err = PTR_ERR(vb_mapping);
+		if (err != -EOPNOTSUPP)
+			goto out_free_vb_devinfo;
+	}
+
+	vb->vb_dev_info = vb_devinfo;
+
 	err = init_vqs(vb);
 	if (err)
-		goto out_free_vb;
+		goto out_free_vb_mapping;
  
 	vb->thread = kthread_run(balloon, vb, "vballoon");
 	if (IS_ERR(vb->thread)) {
@@ -371,6 +478,10 @@
  
 out_del_vqs:
 	vdev->config->del_vqs(vdev);
+out_free_vb_mapping:
+	balloon_mapping_free(vb_mapping);
+out_free_vb_devinfo:
+	balloon_devinfo_free(vb_devinfo);
 out_free_vb:
 	kfree(vb);
 out:
@@ -396,6 +507,8 @@
  
 	kthread_stop(vb->thread);
 	remove_common(vb);
+	balloon_mapping_free(vb->vb_dev_info->mapping);
+	balloon_devinfo_free(vb->vb_dev_info);
 	kfree(vb);
 }
...	...	@@ -27,13 +27,15 @@
27	27	#include <linux/delay.h>
28	28	#include <linux/slab.h>
29	29	#include <linux/module.h>
	30	+#include <linux/balloon_compaction.h>
30	31
31	32	/*
32	33	* Balloon device works in 4K page units. So each page is pointed to by
33	34	* multiple balloon pages. All memory counters in this driver are in balloon
34	35	* page units.
35	36	*/
36		-#define VIRTIO_BALLOON_PAGES_PER_PAGE (PAGE_SIZE >> VIRTIO_BALLOON_PFN_SHIFT)
	37	+#define VIRTIO_BALLOON_PAGES_PER_PAGE (unsigned)(PAGE_SIZE >> VIRTIO_BALLOON_PFN_SHIFT)
	38	+#define VIRTIO_BALLOON_ARRAY_PFNS_MAX 256
37	39
38	40	struct virtio_balloon
39	41	{
40	42
41	43
42	44
...	...	@@ -52,15 +54,19 @@
52	54	/* Number of balloon pages we've told the Host we're not using. */
53	55	unsigned int num_pages;
54	56	/*
55		- * The pages we've told the Host we're not using.
	57	+ * The pages we've told the Host we're not using are enqueued
	58	+ * at vb_dev_info->pages list.
56	59	* Each page on this list adds VIRTIO_BALLOON_PAGES_PER_PAGE
57	60	* to num_pages above.
58	61	*/
59		- struct list_head pages;
	62	+ struct balloon_dev_info *vb_dev_info;
60	63
	64	+ /* Synchronize access/update to this struct virtio_balloon elements */
	65	+ struct mutex balloon_lock;
	66	+
61	67	/* The array of pfns we tell the Host about. */
62	68	unsigned int num_pfns;
63		- u32 pfns[256];
	69	+ u32 pfns[VIRTIO_BALLOON_ARRAY_PFNS_MAX];
64	70
65	71	/* Memory statistics */
66	72	int need_stats_update;
67	73
68	74
69	75
...	...	@@ -122,18 +128,21 @@
122	128
123	129	static void fill_balloon(struct virtio_balloon *vb, size_t num)
124	130	{
	131	+ struct balloon_dev_info *vb_dev_info = vb->vb_dev_info;
	132	+
125	133	/* We can only do one array worth at a time. */
126	134	num = min(num, ARRAY_SIZE(vb->pfns));
127	135
	136	+ mutex_lock(&vb->balloon_lock);
128	137	for (vb->num_pfns = 0; vb->num_pfns < num;
129	138	vb->num_pfns += VIRTIO_BALLOON_PAGES_PER_PAGE) {
130		- struct page *page = alloc_page(GFP_HIGHUSER \| __GFP_NORETRY \|
131		- __GFP_NOMEMALLOC \| __GFP_NOWARN);
	139	+ struct page *page = balloon_page_enqueue(vb_dev_info);
	140	+
132	141	if (!page) {
133	142	if (printk_ratelimit())
134	143	dev_printk(KERN_INFO, &vb->vdev->dev,
135		- "Out of puff! Can't get %zu pages\n",
136		- num);
	144	+ "Out of puff! Can't get %u pages\n",
	145	+ VIRTIO_BALLOON_PAGES_PER_PAGE);
137	146	/* Sleep for at least 1/5 of a second before retry. */
138	147	msleep(200);
139	148	break;
140	149
...	...	@@ -141,14 +150,12 @@
141	150	set_page_pfns(vb->pfns + vb->num_pfns, page);
142	151	vb->num_pages += VIRTIO_BALLOON_PAGES_PER_PAGE;
143	152	totalram_pages--;
144		- list_add(&page->lru, &vb->pages);
145	153	}
146	154
147		- /* Didn't get any? Oh well. */
148		- if (vb->num_pfns == 0)
149		- return;
150		-
151		- tell_host(vb, vb->inflate_vq);
	155	+ /* Did we get any? */
	156	+ if (vb->num_pfns != 0)
	157	+ tell_host(vb, vb->inflate_vq);
	158	+ mutex_unlock(&vb->balloon_lock);
152	159	}
153	160
154	161	static void release_pages_by_pfn(const u32 pfns[], unsigned int num)
...	...	@@ -157,7 +164,7 @@
157	164
158	165	/* Find pfns pointing at start of each page, get pages and free them. */
159	166	for (i = 0; i < num; i += VIRTIO_BALLOON_PAGES_PER_PAGE) {
160		- __free_page(balloon_pfn_to_page(pfns[i]));
	167	+ balloon_page_free(balloon_pfn_to_page(pfns[i]));
161	168	totalram_pages++;
162	169	}
163	170	}
164	171
165	172
...	...	@@ -165,14 +172,17 @@
165	172	static void leak_balloon(struct virtio_balloon *vb, size_t num)
166	173	{
167	174	struct page *page;
	175	+ struct balloon_dev_info *vb_dev_info = vb->vb_dev_info;
168	176
169	177	/* We can only do one array worth at a time. */
170	178	num = min(num, ARRAY_SIZE(vb->pfns));
171	179
	180	+ mutex_lock(&vb->balloon_lock);
172	181	for (vb->num_pfns = 0; vb->num_pfns < num;
173	182	vb->num_pfns += VIRTIO_BALLOON_PAGES_PER_PAGE) {
174		- page = list_first_entry(&vb->pages, struct page, lru);
175		- list_del(&page->lru);
	183	+ page = balloon_page_dequeue(vb_dev_info);
	184	+ if (!page)
	185	+ break;
176	186	set_page_pfns(vb->pfns + vb->num_pfns, page);
177	187	vb->num_pages -= VIRTIO_BALLOON_PAGES_PER_PAGE;
178	188	}
...	...	@@ -183,6 +193,7 @@
183	193	* is true, we have to do it in this order
184	194	*/
185	195	tell_host(vb, vb->deflate_vq);
	196	+ mutex_unlock(&vb->balloon_lock);
186	197	release_pages_by_pfn(vb->pfns, vb->num_pfns);
187	198	}
188	199
189	200
...	...	@@ -339,9 +350,84 @@
339	350	return 0;
340	351	}
341	352
	353	+static const struct address_space_operations virtio_balloon_aops;
	354	+#ifdef CONFIG_BALLOON_COMPACTION
	355	+/*
	356	+ * virtballoon_migratepage - perform the balloon page migration on behalf of
	357	+ * a compation thread. (called under page lock)
	358	+ * @mapping: the page->mapping which will be assigned to the new migrated page.
	359	+ * @newpage: page that will replace the isolated page after migration finishes.
	360	+ * @page : the isolated (old) page that is about to be migrated to newpage.
	361	+ * @mode : compaction mode -- not used for balloon page migration.
	362	+ *
	363	+ * After a ballooned page gets isolated by compaction procedures, this is the
	364	+ * function that performs the page migration on behalf of a compaction thread
	365	+ * The page migration for virtio balloon is done in a simple swap fashion which
	366	+ * follows these two macro steps:
	367	+ * 1) insert newpage into vb->pages list and update the host about it;
	368	+ * 2) update the host about the old page removed from vb->pages list;
	369	+ *
	370	+ * This function preforms the balloon page migration task.
	371	+ * Called through balloon_mapping->a_ops->migratepage
	372	+ */
	373	+int virtballoon_migratepage(struct address_space *mapping,
	374	+ struct page newpage, struct page page, enum migrate_mode mode)
	375	+{
	376	+ struct balloon_dev_info *vb_dev_info = balloon_page_device(page);
	377	+ struct virtio_balloon *vb;
	378	+ unsigned long flags;
	379	+
	380	+ BUG_ON(!vb_dev_info);
	381	+
	382	+ vb = vb_dev_info->balloon_device;
	383	+
	384	+ /*
	385	+ * In order to avoid lock contention while migrating pages concurrently
	386	+ * to leak_balloon() or fill_balloon() we just give up the balloon_lock
	387	+ * this turn, as it is easier to retry the page migration later.
	388	+ * This also prevents fill_balloon() getting stuck into a mutex
	389	+ * recursion in the case it ends up triggering memory compaction
	390	+ * while it is attempting to inflate the ballon.
	391	+ */
	392	+ if (!mutex_trylock(&vb->balloon_lock))
	393	+ return -EAGAIN;
	394	+
	395	+ /* balloon's page migration 1st step -- inflate "newpage" */
	396	+ spin_lock_irqsave(&vb_dev_info->pages_lock, flags);
	397	+ balloon_page_insert(newpage, mapping, &vb_dev_info->pages);
	398	+ vb_dev_info->isolated_pages--;
	399	+ spin_unlock_irqrestore(&vb_dev_info->pages_lock, flags);
	400	+ vb->num_pfns = VIRTIO_BALLOON_PAGES_PER_PAGE;
	401	+ set_page_pfns(vb->pfns, newpage);
	402	+ tell_host(vb, vb->inflate_vq);
	403	+
	404	+ /*
	405	+ * balloon's page migration 2nd step -- deflate "page"
	406	+ *
	407	+ * It's safe to delete page->lru here because this page is at
	408	+ * an isolated migration list, and this step is expected to happen here
	409	+ */
	410	+ balloon_page_delete(page);
	411	+ vb->num_pfns = VIRTIO_BALLOON_PAGES_PER_PAGE;
	412	+ set_page_pfns(vb->pfns, page);
	413	+ tell_host(vb, vb->deflate_vq);
	414	+
	415	+ mutex_unlock(&vb->balloon_lock);
	416	+
	417	+ return MIGRATEPAGE_BALLOON_SUCCESS;
	418	+}
	419	+
	420	+/* define the balloon_mapping->a_ops callback to allow balloon page migration */
	421	+static const struct address_space_operations virtio_balloon_aops = {
	422	+ .migratepage = virtballoon_migratepage,
	423	+};
	424	+#endif /* CONFIG_BALLOON_COMPACTION */
	425	+
342	426	static int virtballoon_probe(struct virtio_device *vdev)
343	427	{
344	428	struct virtio_balloon *vb;
	429	+ struct address_space *vb_mapping;
	430	+ struct balloon_dev_info *vb_devinfo;
345	431	int err;
346	432
347	433	vdev->priv = vb = kmalloc(sizeof(*vb), GFP_KERNEL);
348	434
349	435
350	436
...	...	@@ -350,16 +436,37 @@
350	436	goto out;
351	437	}
352	438
353		- INIT_LIST_HEAD(&vb->pages);
354	439	vb->num_pages = 0;
	440	+ mutex_init(&vb->balloon_lock);
355	441	init_waitqueue_head(&vb->config_change);
356	442	init_waitqueue_head(&vb->acked);
357	443	vb->vdev = vdev;
358	444	vb->need_stats_update = 0;
359	445
	446	+ vb_devinfo = balloon_devinfo_alloc(vb);
	447	+ if (IS_ERR(vb_devinfo)) {
	448	+ err = PTR_ERR(vb_devinfo);
	449	+ goto out_free_vb;
	450	+ }
	451	+
	452	+ vb_mapping = balloon_mapping_alloc(vb_devinfo,
	453	+ (balloon_compaction_check()) ?
	454	+ &virtio_balloon_aops : NULL);
	455	+ if (IS_ERR(vb_mapping)) {
	456	+ /*
	457	+ * IS_ERR(vb_mapping) && PTR_ERR(vb_mapping) == -EOPNOTSUPP
	458	+ * This means !CONFIG_BALLOON_COMPACTION, otherwise we get off.
	459	+ */
	460	+ err = PTR_ERR(vb_mapping);
	461	+ if (err != -EOPNOTSUPP)
	462	+ goto out_free_vb_devinfo;
	463	+ }
	464	+
	465	+ vb->vb_dev_info = vb_devinfo;
	466	+
360	467	err = init_vqs(vb);
361	468	if (err)
362		- goto out_free_vb;
	469	+ goto out_free_vb_mapping;
363	470
364	471	vb->thread = kthread_run(balloon, vb, "vballoon");
365	472	if (IS_ERR(vb->thread)) {
...	...	@@ -371,6 +478,10 @@
371	478
372	479	out_del_vqs:
373	480	vdev->config->del_vqs(vdev);
	481	+out_free_vb_mapping:
	482	+ balloon_mapping_free(vb_mapping);
	483	+out_free_vb_devinfo:
	484	+ balloon_devinfo_free(vb_devinfo);
374	485	out_free_vb:
375	486	kfree(vb);
376	487	out:
...	...	@@ -396,6 +507,8 @@
396	507
397	508	kthread_stop(vb->thread);
398	509	remove_common(vb);
	510	+ balloon_mapping_free(vb->vb_dev_info->mapping);
	511	+ balloon_devinfo_free(vb->vb_dev_info);
399	512	kfree(vb);
400	513	}
401	514