Skip to contentSkip to conversation

mm/hugetlb: correct demote page offset logic

PATCH Applied Doug Berger 5 participants 7 messages Sep 14, 2022 – Sep 15, 2022

Subsystems (3)
lore
Share & tools
lore
#0 lore raw

PATCH 1/1 mm/hugetlb: correct demote page offset logic

With gigantic pages it may not be true that struct page structures are contiguous across the entire gigantic page. The nth_page macro is used here in place of direct pointer arithmetic to correct for this.

Fixes 8531fc6f52f5 ("hugetlb: add hugetlb demote page support")
---
 mm/hugetlb.c | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)
mm/hugetlb.c +8 -6
index e070b8593b37..0bdfc7e1c933 100644
@@ -3420,6 +3420,7 @@ static int demote_free_huge_page(struct hstate *h, struct page *page)
 {
 	int i, nid = page_to_nid(page);
 	struct hstate *target_hstate;
+	struct page *subpage;
 	int rc = 0;
 
 	target_hstate = size_to_hstate(PAGE_SIZE << h->demote_order);
@@ -3453,15 +3454,16 @@ static int demote_free_huge_page(struct hstate *h, struct page *page)
 	mutex_lock(&target_hstate->resize_lock);
 	for (i = 0; i < pages_per_huge_page(h);
 				i += pages_per_huge_page(target_hstate)) {
+		subpage = nth_page(page, i);
 		if (hstate_is_gigantic(target_hstate))
-			prep_compound_gigantic_page_for_demote(page + i,
+			prep_compound_gigantic_page_for_demote(subpage,
 							target_hstate->order);
 		else
-			prep_compound_page(page + i, target_hstate->order);
-		set_page_private(page + i, 0);
-		set_page_refcounted(page + i);
-		prep_new_huge_page(target_hstate, page + i, nid);
-		put_page(page + i);
+			prep_compound_page(subpage, target_hstate->order);
+		set_page_private(subpage, 0);
+		set_page_refcounted(subpage);
+		prep_new_huge_page(target_hstate, subpage, nid);
+		put_page(subpage);
 	}
 	mutex_unlock(&target_hstate->resize_lock);
 
Signature · 1 line
2.25.1
maintainer
#1 lore raw
Quoted 4 lines · On Wed, 14 Sep 2022 12:09:17 -0700 Doug Berger <[email protected]> wrote:

With gigantic pages it may not be true that struct page structures are contiguous across the entire gigantic page. The nth_page macro is used here in place of direct pointer arithmetic to correct for this.

What were the user-visible runtime effects of this bug?

#2 lore raw
Quoted 8 lines · Andrew Morton
Quoted 4 lines · On Wed, 14 Sep 2022 12:09:17 -0700 Doug Berger <[email protected]> wrote:

With gigantic pages it may not be true that struct page structures are contiguous across the entire gigantic page. The nth_page macro is used here in place of direct pointer arithmetic to correct for this.

What were the user-visible runtime effects of this bug?

As Mike said this would only conceptually be a problem for systems with CONFIG_SPARSEMEM && !CONFIG_SPARSEMEM_VMEMMAP, and could cause kernel address exceptions or memory corruption with unpredictable side effects.

However, I am unaware of a system other than perhaps the PS3 that uses the classic sparse addressing, so the odds of such a system also using gigantic hugetlbfs pages that it wants to demote is likely quite small.

Thanks,
-Doug

Reviewed-by on v1 1/1
#3 lore raw
In reply to Doug Berger
Quoted 11 lines · Doug Berger

With gigantic pages it may not be true that struct page structures are contiguous across the entire gigantic page. The nth_page macro is used here in place of direct pointer arithmetic to correct for this.

Fixes 8531fc6f52f5 ("hugetlb: add hugetlb demote page support")
---
 mm/hugetlb.c | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

Thanks!

To answer Andrew's question about user-visible runtime effects. We could get addressing exceptions. However, this is only possible in configurations where CONFIG_SPARSEMEM && !CONFIG_SPARSEMEM_VMEMMAP. Such a configuration option is rare an unknown to be the default anywhere.

Signature · 1 line
Mike Kravetz
#4 lore raw
Quoted 15 lines · Mike Kravetz
Quoted 11 lines · Doug Berger

With gigantic pages it may not be true that struct page structures are contiguous across the entire gigantic page. The nth_page macro is used here in place of direct pointer arithmetic to correct for this.

Fixes 8531fc6f52f5 ("hugetlb: add hugetlb demote page support")
---
 mm/hugetlb.c | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

Thanks!

Quoted 7 lines

To answer Andrew's question about user-visible runtime effects. We could get addressing exceptions. However, this is only possible in configurations where CONFIG_SPARSEMEM && !CONFIG_SPARSEMEM_VMEMMAP. Such a configuration option is rare an unknown to be the default anywhere.

In that case, should this be a 'Cc: stable' ? Although it does fix the above mentioned commit for a possible configuration. But should this be backported, if there could not have been an affected system ?

Reviewed-by on v1 1/1
#5 lore raw
In reply to Doug Berger
Quoted 8 lines · Doug Berger

With gigantic pages it may not be true that struct page structures are contiguous across the entire gigantic page. The nth_page macro is used here in place of direct pointer arithmetic to correct for this.

Fixes 8531fc6f52f5 ("hugetlb: add hugetlb demote page support")
Quoted 39 lines
---
 mm/hugetlb.c | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)
mm/hugetlb.c +8 -6
index e070b8593b37..0bdfc7e1c933 100644
@@ -3420,6 +3420,7 @@ static int demote_free_huge_page(struct hstate *h, struct page *page)
 {
 	int i, nid = page_to_nid(page);
 	struct hstate *target_hstate;
+	struct page *subpage;
 	int rc = 0;
 
 	target_hstate = size_to_hstate(PAGE_SIZE << h->demote_order);
@@ -3453,15 +3454,16 @@ static int demote_free_huge_page(struct hstate *h, struct page *page)
 	mutex_lock(&target_hstate->resize_lock);
 	for (i = 0; i < pages_per_huge_page(h);
 				i += pages_per_huge_page(target_hstate)) {
+		subpage = nth_page(page, i);
 		if (hstate_is_gigantic(target_hstate))
-			prep_compound_gigantic_page_for_demote(page + i,
+			prep_compound_gigantic_page_for_demote(subpage,
 							target_hstate->order);
 		else
-			prep_compound_page(page + i, target_hstate->order);
-		set_page_private(page + i, 0);
-		set_page_refcounted(page + i);
-		prep_new_huge_page(target_hstate, page + i, nid);
-		put_page(page + i);
+			prep_compound_page(subpage, target_hstate->order);
+		set_page_private(subpage, 0);
+		set_page_refcounted(subpage);
+		prep_new_huge_page(target_hstate, subpage, nid);
+		put_page(subpage);
 	}
 	mutex_unlock(&target_hstate->resize_lock);
 
maintainer Reviewed-by on v1 1/1
#6 lore raw
In reply to Doug Berger
Quoted 8 lines · Doug Berger

With gigantic pages it may not be true that struct page structures are contiguous across the entire gigantic page. The nth_page macro is used here in place of direct pointer arithmetic to correct for this.

Fixes 8531fc6f52f5 ("hugetlb: add hugetlb demote page support")
Signature · 2 lines
Oscar Salvador
SUSE Labs