Skip to contentSkip to conversation

xen/balloon: fix page onlining when populating new zone

PATCH In review Juergen Gross 4 participants 8 messages Apr 6, 2022 – Apr 8, 2022

Subsystems (2)
lore
Share & tools
lore

Juergen Gross

author maintainer
#0 lore raw

PATCH 1/1 xen/balloon: fix page onlining when populating new zone

When onlining a new memory page in a guest the Xen balloon driver is adding it to the ballooned pages instead making it available to be used immediately. This is meant to enable to add a new upper memory limit to a guest via hotplugging memory, without having to assign the new memory in one go.

In case the upper memory limit will be raised above 4G, the new memory will populate the ZONE_NORMAL memory zone, which wasn't populated before. The newly populated zone won't be added to the list of zones looked at by the page allocator though, as only zones with available memory are being added, and the memory isn't yet available as it is ballooned out.

This will result in the new memory being assigned to the guest, but without the allocator being able to use it.

When running as a PV guest the situation is even worse: when having been started with less memory than allowed, and the upper limit being lower than 4G, ballooning up will have the same effect as hotplugging new memory. This is due to the usage of the zone device functionality since commit 9e2369c06c8a ("xen: add helpers to allocate unpopulated memory") for creating mappings of other guest's pages, which as a side effect is being used for PV guest ballooning, too.

Fix this by checking in xen_online_page() whether the new memory page will be the first in a new zone. If this is the case, add another page to the balloon and use the first memory page of the new chunk as a replacement for this now ballooned out page. This will result in the newly populated zone containing one page being available for the page allocator, which in turn will lead to the zone being added to the allocator.

Fixes 9e2369c06c8a ("xen: add helpers to allocate unpopulated memory")
---
 drivers/xen/balloon.c | 72 ++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 65 insertions(+), 7 deletions(-)
drivers/xen/balloon.c +65 -7
index dfe26fa17e95..f895c54c4c65 100644
@@ -355,14 +355,77 @@ static enum bp_state reserve_additional_memory(void)
 	return BP_ECANCELED;
 }
 
+static struct page *alloc_page_for_balloon(gfp_t gfp)
+{
+	struct page *page;
+
+	page = alloc_page(gfp);
+	if (page == NULL)
+		return NULL;
+
+	adjust_managed_page_count(page, -1);
+	xenmem_reservation_scrub_page(page);
+
+	return page;
+}
+
+static void add_page_to_balloon(struct page *page)
+{
+	xenmem_reservation_va_mapping_reset(1, &page);
+	balloon_append(page);
+}
+
 static void xen_online_page(struct page *page, unsigned int order)
 {
 	unsigned long i, size = (1 << order);
 	unsigned long start_pfn = page_to_pfn(page);
 	struct page *p;
+	struct zone *zone;
 
 	pr_debug("Online %lu pages starting at pfn 0x%lx\n", size, start_pfn);
 	mutex_lock(&balloon_mutex);
+	zone = page_zone(pfn_to_page(start_pfn));
+
+	/*
+	 * In case a new memory zone is going to be populated, we need to
+	 * ensure at least one page is made available for the memory allocator.
+	 * As the number of pages per zone is updated only after a batch of
+	 * pages having been added, use the number of managed pages as an
+	 * additional indicator for a new zone.
+	 * Otherwise this zone won't be added to the zonelist resulting in the
+	 * zone's memory not usable by the kernel.
+	 * Add an already valid page to the balloon and replace it with the
+	 * first page of the to be added new memory chunk.
+	 */
+	if (!populated_zone(zone) && !managed_zone(zone)) {
+		xen_pfn_t frame;
+
+		pr_info("Populating new zone\n");
+
+		p = alloc_page_for_balloon(GFP_ATOMIC);
+		if (!p) {
+			pr_err("Failed to allocate replacement balloon page!\n");
+			pr_err("New onlined memory might not be usable.\n");
+		} else {
+			kmap_flush_unused();
+			add_page_to_balloon(p);
+			flush_tlb_all();
+			frame = xen_page_to_gfn(p);
+			xenmem_reservation_decrease(1, &frame);
+			balloon_stats.current_pages--;
+		}
+
+		p = pfn_to_page(start_pfn);
+		frame = page_to_xen_pfn(p);
+		if (xenmem_reservation_increase(1, &frame) > 0) {
+			xenmem_reservation_va_mapping_update(1, &p, &frame);
+			free_reserved_page(p);
+			balloon_stats.current_pages++;
+
+			start_pfn++;
+			size--;
+		}
+	}
 	for (i = 0; i < size; i++) {
 		p = pfn_to_page(start_pfn + i);
 		balloon_append(p);
@@ -452,14 +515,12 @@ static enum bp_state decrease_reservation(unsigned long nr_pages, gfp_t gfp)
 		nr_pages = ARRAY_SIZE(frame_list);
 
 	for (i = 0; i < nr_pages; i++) {
-		page = alloc_page(gfp);
+		page = alloc_page_for_balloon(gfp);
 		if (page == NULL) {
 			nr_pages = i;
 			state = BP_EAGAIN;
 			break;
 		}
-		adjust_managed_page_count(page, -1);
-		xenmem_reservation_scrub_page(page);
 		list_add(&page->lru, &pages);
 	}
 
@@ -480,11 +541,8 @@ static enum bp_state decrease_reservation(unsigned long nr_pages, gfp_t gfp)
 	list_for_each_entry_safe(page, tmp, &pages, lru) {
 		frame_list[i++] = xen_page_to_gfn(page);
 
-		xenmem_reservation_va_mapping_reset(1, &page);
-
 		list_del(&page->lru);
-
-		balloon_append(page);
+		add_page_to_balloon(page);
 	}
 
 	flush_tlb_all();
Signature · 1 line
2.34.1
#1 lore raw
I love your patch! Perhaps something to improve:

Hi Juergen,

I love your patch! Perhaps something to improve:

[auto build test WARNING on xen-tip/linux-next]
[also build test WARNING on linus/master linux/master v5.18-rc1 next-20220406] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]

url:    https://github.com/intel-lab-lkp/linux/commits/Juergen-Gross/xen-balloon-fix-page-onlining-when-populating-new-zone/20220407-000935
base:   https://git.kernel.org/pub/scm/linux/kernel/git/xen/tip.git linux-next
config: arm64-randconfig-r011-20220406 (https://download.01.org/0day-ci/archive/20220407/[email protected]/config)
compiler: aarch64-linux-gcc (GCC) 11.2.0

reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# https://github.com/intel-lab-lkp/linux/commit/b3deb59d5386ade4fb227038f202a9bdb8ade4ab
git remote add linux-review https://github.com/intel-lab-lkp/linux
git fetch --no-tags linux-review Juergen-Gross/xen-balloon-fix-page-onlining-when-populating-new-zone/20220407-000935 git checkout b3deb59d5386ade4fb227038f202a9bdb8ade4ab
# save the config file to linux build tree
mkdir build_dir
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-11.2.0 make.cross O=build_dir ARCH=arm64 SHELL=/bin/bash drivers/xen/

If you fix the issue, kindly add following tag as appropriate

All warnings (new ones prefixed by >>):

drivers/xen/balloon.c: In function 'decrease_reservation':
drivers/xen/balloon.c:518:24: error: implicit declaration of function 'alloc_page_for_balloon' [-Werror=implicit-function-declaration]

     518 |                 page = alloc_page_for_balloon(gfp);
         |                        ^~~~~~~~~~~~~~~~~~~~~~
>> drivers/xen/balloon.c:518:22: warning: assignment to 'struct page *' from 'int' makes pointer from integer without a cast [-Wint-conversion]
     518 |                 page = alloc_page_for_balloon(gfp);
         |                      ^
   drivers/xen/balloon.c:545:17: error: implicit declaration of function 'add_page_to_balloon' [-Werror=implicit-function-declaration]
     545 |                 add_page_to_balloon(page);
         |                 ^~~~~~~~~~~~~~~~~~~

cc1: some warnings being treated as errors

vim +518 drivers/xen/balloon.c

505
506 static enum bp_state decrease_reservation(unsigned long nr_pages, gfp_t gfp)
507 {
508 enum bp_state state = BP_DONE;
509 unsigned long i;
510 struct page *page, *tmp;
511 int ret;
512 LIST_HEAD(pages);
513
514 if (nr_pages > ARRAY_SIZE(frame_list))
515 nr_pages = ARRAY_SIZE(frame_list);
516
517 for (i = 0; i < nr_pages; i++) {

 > 518			page = alloc_page_for_balloon(gfp);

519 if (page == NULL) {
520 nr_pages = i;
521 state = BP_EAGAIN;
522 break;
523 }
524 list_add(&page->lru, &pages);
525 }
526
527 /*
528 * Ensure that ballooned highmem pages don't have kmaps.
529 *
530 * Do this before changing the p2m as kmap_flush_unused()
531 * reads PTEs to obtain pages (and hence needs the original
532 * p2m entry).
533 */
534 kmap_flush_unused();
535
536 /*
537 * Setup the frame, update direct mapping, invalidate P2M,
538 * and add to balloon.
539 */
540 i = 0;
541 list_for_each_entry_safe(page, tmp, &pages, lru) {
542 frame_list[i++] = xen_page_to_gfn(page);
543
544 list_del(&page->lru);
545 add_page_to_balloon(page);
546 }
547
548 flush_tlb_all();
549
550 ret = xenmem_reservation_decrease(nr_pages, frame_list);
551 BUG_ON(ret != nr_pages);
552
553 balloon_stats.current_pages -= nr_pages;
554
555 return state;
556 }
557

Signature · 2 lines
0-DAY CI Kernel Test Service
https://01.org/lkp
#2 lore raw
In reply to Juergen Gross
I love your patch! Perhaps something to improve:

Hi Juergen,

I love your patch! Perhaps something to improve:

[auto build test WARNING on xen-tip/linux-next]
[also build test WARNING on linus/master linux/master v5.18-rc1 next-20220406] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]

url:    https://github.com/intel-lab-lkp/linux/commits/Juergen-Gross/xen-balloon-fix-page-onlining-when-populating-new-zone/20220407-000935
base:   https://git.kernel.org/pub/scm/linux/kernel/git/xen/tip.git linux-next
config: arm64-randconfig-r036-20220406 (https://download.01.org/0day-ci/archive/20220407/[email protected]/config)
compiler: clang version 15.0.0 (https://github.com/llvm/llvm-project c4a1b07d0979e7ff20d7d541af666d822d66b566)

reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
chmod +x ~/bin/make.cross
# install arm64 cross compiling tool for clang build
# apt-get install binutils-aarch64-linux-gnu
# https://github.com/intel-lab-lkp/linux/commit/b3deb59d5386ade4fb227038f202a9bdb8ade4ab
git remote add linux-review https://github.com/intel-lab-lkp/linux
git fetch --no-tags linux-review Juergen-Gross/xen-balloon-fix-page-onlining-when-populating-new-zone/20220407-000935 git checkout b3deb59d5386ade4fb227038f202a9bdb8ade4ab
# save the config file to linux build tree
mkdir build_dir
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross W=1 O=build_dir ARCH=arm64 SHELL=/bin/bash drivers/media/platform/ drivers/xen/

If you fix the issue, kindly add following tag as appropriate

All warnings (new ones prefixed by >>):

drivers/xen/balloon.c:518:10: error: implicit declaration of function 'alloc_page_for_balloon' [-Werror,-Wimplicit-function-declaration]

                   page = alloc_page_for_balloon(gfp);
                          ^
>> drivers/xen/balloon.c:518:8: warning: incompatible integer to pointer conversion assigning to 'struct page *' from 'int' [-Wint-conversion]
                   page = alloc_page_for_balloon(gfp);
                        ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~
   drivers/xen/balloon.c:545:3: error: implicit declaration of function 'add_page_to_balloon' [-Werror,-Wimplicit-function-declaration]
                   add_page_to_balloon(page);
                   ^

1 warning and 2 errors generated.

vim +518 drivers/xen/balloon.c

505
506 static enum bp_state decrease_reservation(unsigned long nr_pages, gfp_t gfp)
507 {
508 enum bp_state state = BP_DONE;
509 unsigned long i;
510 struct page *page, *tmp;
511 int ret;
512 LIST_HEAD(pages);
513
514 if (nr_pages > ARRAY_SIZE(frame_list))
515 nr_pages = ARRAY_SIZE(frame_list);
516
517 for (i = 0; i < nr_pages; i++) {

 > 518			page = alloc_page_for_balloon(gfp);

519 if (page == NULL) {
520 nr_pages = i;
521 state = BP_EAGAIN;
522 break;
523 }
524 list_add(&page->lru, &pages);
525 }
526
527 /*
528 * Ensure that ballooned highmem pages don't have kmaps.
529 *
530 * Do this before changing the p2m as kmap_flush_unused()
531 * reads PTEs to obtain pages (and hence needs the original
532 * p2m entry).
533 */
534 kmap_flush_unused();
535
536 /*
537 * Setup the frame, update direct mapping, invalidate P2M,
538 * and add to balloon.
539 */
540 i = 0;
541 list_for_each_entry_safe(page, tmp, &pages, lru) {
542 frame_list[i++] = xen_page_to_gfn(page);
543
544 list_del(&page->lru);
545 add_page_to_balloon(page);
546 }
547
548 flush_tlb_all();
549
550 ret = xenmem_reservation_decrease(nr_pages, frame_list);
551 BUG_ON(ret != nr_pages);
552
553 balloon_stats.current_pages -= nr_pages;
554
555 return state;
556 }
557

Signature · 2 lines
0-DAY CI Kernel Test Service
https://01.org/lkp
#3 lore raw
In reply to Juergen Gross
I love your patch! Yet something to improve:

Hi Juergen,

I love your patch! Yet something to improve:

[auto build test ERROR on xen-tip/linux-next]
[also build test ERROR on linus/master linux/master v5.18-rc1 next-20220406] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]

url:    https://github.com/intel-lab-lkp/linux/commits/Juergen-Gross/xen-balloon-fix-page-onlining-when-populating-new-zone/20220407-000935
base:   https://git.kernel.org/pub/scm/linux/kernel/git/xen/tip.git linux-next
config: arm64-randconfig-r011-20220406 (https://download.01.org/0day-ci/archive/20220407/[email protected]/config)
compiler: aarch64-linux-gcc (GCC) 11.2.0

reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# https://github.com/intel-lab-lkp/linux/commit/b3deb59d5386ade4fb227038f202a9bdb8ade4ab
git remote add linux-review https://github.com/intel-lab-lkp/linux
git fetch --no-tags linux-review Juergen-Gross/xen-balloon-fix-page-onlining-when-populating-new-zone/20220407-000935 git checkout b3deb59d5386ade4fb227038f202a9bdb8ade4ab
# save the config file to linux build tree
mkdir build_dir
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-11.2.0 make.cross O=build_dir ARCH=arm64 SHELL=/bin/bash drivers/

If you fix the issue, kindly add following tag as appropriate

All errors (new ones prefixed by >>):

drivers/xen/balloon.c: In function 'decrease_reservation':

>> drivers/xen/balloon.c:518:24: error: implicit declaration of function 'alloc_page_for_balloon' [-Werror=implicit-function-declaration]
     518 |                 page = alloc_page_for_balloon(gfp);
         |                        ^~~~~~~~~~~~~~~~~~~~~~
   drivers/xen/balloon.c:518:22: warning: assignment to 'struct page *' from 'int' makes pointer from integer without a cast [-Wint-conversion]
     518 |                 page = alloc_page_for_balloon(gfp);
         |                      ^
>> drivers/xen/balloon.c:545:17: error: implicit declaration of function 'add_page_to_balloon' [-Werror=implicit-function-declaration]
     545 |                 add_page_to_balloon(page);
         |                 ^~~~~~~~~~~~~~~~~~~

cc1: some warnings being treated as errors

vim +/alloc_page_for_balloon +518 drivers/xen/balloon.c

505
506 static enum bp_state decrease_reservation(unsigned long nr_pages, gfp_t gfp)
507 {
508 enum bp_state state = BP_DONE;
509 unsigned long i;
510 struct page *page, *tmp;
511 int ret;
512 LIST_HEAD(pages);
513
514 if (nr_pages > ARRAY_SIZE(frame_list))
515 nr_pages = ARRAY_SIZE(frame_list);
516
517 for (i = 0; i < nr_pages; i++) {

 > 518			page = alloc_page_for_balloon(gfp);
   519			if (page == NULL) {
   520				nr_pages = i;
   521				state = BP_EAGAIN;
   522				break;
   523			}
   524			list_add(&page->lru, &pages);
   525		}
   526	
   527		/*
   528		 * Ensure that ballooned highmem pages don't have kmaps.
   529		 *
   530		 * Do this before changing the p2m as kmap_flush_unused()
   531		 * reads PTEs to obtain pages (and hence needs the original
   532		 * p2m entry).
   533		 */
   534		kmap_flush_unused();
   535	
   536		/*
   537		 * Setup the frame, update direct mapping, invalidate P2M,
   538		 * and add to balloon.
   539		 */
   540		i = 0;
   541		list_for_each_entry_safe(page, tmp, &pages, lru) {
   542			frame_list[i++] = xen_page_to_gfn(page);
   543	
   544			list_del(&page->lru);
 > 545			add_page_to_balloon(page);

546 }
547
548 flush_tlb_all();
549
550 ret = xenmem_reservation_decrease(nr_pages, frame_list);
551 BUG_ON(ret != nr_pages);
552
553 balloon_stats.current_pages -= nr_pages;
554
555 return state;
556 }
557

Signature · 2 lines
0-DAY CI Kernel Test Service
https://01.org/lkp
#4 lore raw
In reply to Juergen Gross
Quoted 6 lines · Juergen Gross

When onlining a new memory page in a guest the Xen balloon driver is adding it to the ballooned pages instead making it available to be used immediately. This is meant to enable to add a new upper memory limit to a guest via hotplugging memory, without having to assign the new memory in one go.

Quoted 6 lines

In case the upper memory limit will be raised above 4G, the new memory will populate the ZONE_NORMAL memory zone, which wasn't populated before. The newly populated zone won't be added to the list of zones looked at by the page allocator though, as only zones with available memory are being added, and the memory isn't yet available as it is ballooned out.

I think we just recently discussed these corner cases on the -mm list. The issue is having effectively populated zones without manages pages because everything is inflated in a balloon.

That can theoretically also happen when managing to fully inflate the balloon in one zone and then, somehow, the zones get rebuilt.

build_zonerefs_node() documents "Add all populated zones of a node to the zonelist" but checks for managed zones, which is wrong.

See https://lkml.kernel.org/r/20220201070044.zbm3obsoimhz3xd3@master

Quoted 12 lines

This will result in the new memory being assigned to the guest, but without the allocator being able to use it.

When running as a PV guest the situation is even worse: when having been started with less memory than allowed, and the upper limit being lower than 4G, ballooning up will have the same effect as hotplugging new memory. This is due to the usage of the zone device functionality since commit 9e2369c06c8a ("xen: add helpers to allocate unpopulated memory") for creating mappings of other guest's pages, which as a side effect is being used for PV guest ballooning, too.

Quoted 7 lines

Fix this by checking in xen_online_page() whether the new memory page will be the first in a new zone. If this is the case, add another page to the balloon and use the first memory page of the new chunk as a replacement for this now ballooned out page. This will result in the newly populated zone containing one page being available for the page allocator, which in turn will lead to the zone being added to the allocator.

This somehow feels like a hack for something that should be handled in the core instead :/

Signature · 3 lines
Thanks,

David / dhildenb
author maintainer
#5 lore raw
Quoted 7 lines · David Hildenbrand
Quoted 6 lines · Juergen Gross

When onlining a new memory page in a guest the Xen balloon driver is adding it to the ballooned pages instead making it available to be used immediately. This is meant to enable to add a new upper memory limit to a guest via hotplugging memory, without having to assign the new memory in one go.

Quoted 8 lines
Quoted 6 lines

In case the upper memory limit will be raised above 4G, the new memory will populate the ZONE_NORMAL memory zone, which wasn't populated before. The newly populated zone won't be added to the list of zones looked at by the page allocator though, as only zones with available memory are being added, and the memory isn't yet available as it is ballooned out.

I think we just recently discussed these corner cases on the -mm list.

Indeed.

Quoted 2 lines

The issue is having effectively populated zones without manages pages because everything is inflated in a balloon.

Correct.

Quoted 2 lines

That can theoretically also happen when managing to fully inflate the balloon in one zone and then, somehow, the zones get rebuilt.

I think you are right. I didn't think of that scenario.

Quoted 4 lines

build_zonerefs_node() documents "Add all populated zones of a node to the zonelist" but checks for managed zones, which is wrong.

See https://lkml.kernel.org/r/20220201070044.zbm3obsoimhz3xd3@master

I found commit 6aa303defb7454 which introduced this test. I thought it was needed due to the problem this commit tried to solve. Maybe I was wrong and that commit shouldn't have changed the condition when building the zonelist, but just the ones in the allocation paths.

Quoted 21 lines
Quoted 13 lines

This will result in the new memory being assigned to the guest, but without the allocator being able to use it.

When running as a PV guest the situation is even worse: when having been started with less memory than allowed, and the upper limit being lower than 4G, ballooning up will have the same effect as hotplugging new memory. This is due to the usage of the zone device functionality since commit 9e2369c06c8a ("xen: add helpers to allocate unpopulated memory") for creating mappings of other guest's pages, which as a side effect is being used for PV guest ballooning, too.

Quoted 7 lines

Fix this by checking in xen_online_page() whether the new memory page will be the first in a new zone. If this is the case, add another page to the balloon and use the first memory page of the new chunk as a replacement for this now ballooned out page. This will result in the newly populated zone containing one page being available for the page allocator, which in turn will lead to the zone being added to the allocator.

Quoted 2 lines

This somehow feels like a hack for something that should be handled in the core instead :/

Okay, I'll rework the patch (better wording might be: replace) to switch build_zonerefs_node() to use populated_zone() instead of managed_zone().

Juergen

#6 lore raw
Quoted 32 lines · Juergen Gross
Quoted 7 lines · David Hildenbrand
Quoted 6 lines · Juergen Gross

When onlining a new memory page in a guest the Xen balloon driver is adding it to the ballooned pages instead making it available to be used immediately. This is meant to enable to add a new upper memory limit to a guest via hotplugging memory, without having to assign the new memory in one go.

Quoted 8 lines
Quoted 6 lines

In case the upper memory limit will be raised above 4G, the new memory will populate the ZONE_NORMAL memory zone, which wasn't populated before. The newly populated zone won't be added to the list of zones looked at by the page allocator though, as only zones with available memory are being added, and the memory isn't yet available as it is ballooned out.

I think we just recently discussed these corner cases on the -mm list.

Indeed.

Quoted 2 lines

The issue is having effectively populated zones without manages pages because everything is inflated in a balloon.

Correct.

Quoted 2 lines

That can theoretically also happen when managing to fully inflate the balloon in one zone and then, somehow, the zones get rebuilt.

I think you are right. I didn't think of that scenario.

Quoted 3 lines

build_zonerefs_node() documents "Add all populated zones of a node to the zonelist" but checks for managed zones, which is wrong.

Quoted 6 lines
Quoted 1 line

See https://lkml.kernel.org/r/20220201070044.zbm3obsoimhz3xd3@master

I found commit 6aa303defb7454 which introduced this test. I thought it was needed due to the problem this commit tried to solve. Maybe I was wrong and that commit shouldn't have changed the condition when building the zonelist, but just the ones in the allocation paths.

In regard to kswapd, that is currently being worked on via

https://lkml.kernel.org/r/[email protected]

Signature · 3 lines
Thanks,

David / dhildenb
#7 lore raw
Quoted 35 lines · David Hildenbrand
Quoted 34 lines · Juergen Gross
Quoted 7 lines · David Hildenbrand
Quoted 6 lines · Juergen Gross

When onlining a new memory page in a guest the Xen balloon driver is adding it to the ballooned pages instead making it available to be used immediately. This is meant to enable to add a new upper memory limit to a guest via hotplugging memory, without having to assign the new memory in one go.

Quoted 8 lines
Quoted 6 lines

In case the upper memory limit will be raised above 4G, the new memory will populate the ZONE_NORMAL memory zone, which wasn't populated before. The newly populated zone won't be added to the list of zones looked at by the page allocator though, as only zones with available memory are being added, and the memory isn't yet available as it is ballooned out.

I think we just recently discussed these corner cases on the -mm list.

Indeed.

Quoted 2 lines

The issue is having effectively populated zones without manages pages because everything is inflated in a balloon.

Correct.

Quoted 2 lines

That can theoretically also happen when managing to fully inflate the balloon in one zone and then, somehow, the zones get rebuilt.

I think you are right. I didn't think of that scenario.

Quoted 4 lines

build_zonerefs_node() documents "Add all populated zones of a node to the zonelist" but checks for managed zones, which is wrong.

See https://lkml.kernel.org/r/20220201070044.zbm3obsoimhz3xd3@master

Quoted 9 lines
Quoted 4 lines

I found commit 6aa303defb7454 which introduced this test. I thought it was needed due to the problem this commit tried to solve. Maybe I was wrong and that commit shouldn't have changed the condition when building the zonelist, but just the ones in the allocation paths.

In regard to kswapd, that is currently being worked on via

https://lkml.kernel.org/r/[email protected]

Thanks, David

Do you think it is the right time to repost the original fix?

Quoted 4 lines
Signature · 3 lines
Thanks,

David / dhildenb
Signature · 2 lines
Wei Yang
Help you, Help me