mm-hugetlb_vmemmap-fix-race-with-speculative-pfn-walkers.patch removed from -mm tree
The quilt patch titled
Subject: mm/hugetlb_vmemmap: fix race with speculative PFN walkers
has been removed from the -mm tree. Its filename was
mm-hugetlb_vmemmap-fix-race-with-speculative-pfn-walkers.patch
This patch was dropped because it was merged into the mm-hotfixes-stable branch of git://git.kernel.org/pub/scm/linux/kernel/git/akpm/mm
------------------------------------------------------
From: Yu Zhao <[email protected]>
Subject: mm/hugetlb_vmemmap: fix race with speculative PFN walkers
Date: Thu, 27 Jun 2024 16:27:05 -0600
While investigating HVO for THPs [1], it turns out that speculative PFN walkers like compaction can race with vmemmap modifications, e.g.,
CPU 1 (vmemmap modifier) CPU 2 (speculative PFN walker)
------------------------------- ------------------------------ Allocates an LRU folio page1
Sees page1
Frees page1
Allocates a hugeTLB folio page2
(page1 being a tail of page2)
Updates vmemmap mapping page1
get_page_unless_zero(page1)
Even though page1->_refcount is zero after HVO, get_page_unless_zero() can still try to modify this read-only field, resulting in a crash.
An independent report [2] confirmed this race.
There are two discussed approaches to fix this race:
1. Make RO vmemmap RW so that get_page_unless_zero() can fail without triggering a PF.
2. Use RCU to make sure get_page_unless_zero() either sees zero page->_refcount through the old vmemmap or non-zero page->_refcount through the new one.
The second approach is preferred here because:
1. It can prevent illegal modifications to struct page[] that has been HVO'ed;
2. It can be generalized, in a way similar to ZERO_PAGE(), to fix similar races in other places, e.g., arch_remove_memory() on x86 [3], which frees vmemmap mapping offlined struct page[].
While adding synchronize_rcu(), the goal is to be surgical, rather than optimized. Specifically, calls to synchronize_rcu() on the error handling paths can be coalesced, but it is not done for the sake of Simplicity:
noticeably, this fix removes ~50% more lines than it adds.
According to the hugetlb_optimize_vmemmap section in Documentation/admin-guide/sysctl/vm.rst, enabling HVO makes allocating or freeing hugeTLB pages "~2x slower than before". Having synchronize_rcu() on top makes those operations even worse, and this also affects the user interface /proc/sys/vm/nr_overcommit_hugepages.
This is *very* hard to trigger:
1. Most hugeTLB use cases I know of are static, i.e., reserved at boot time, because allocating at runtime is not reliable at all.
2. On top of that, someone has to be very unlucky to get tripped over above, because the race window is so small -- I wasn't able to trigger it with a stress testing that does nothing but that (with THPs though).
[1] https://lore.kernel.org/[email protected]/
[2] https://lore.kernel.org/[email protected]/
[3] https://lore.kernel.org/[email protected]/
---
include/linux/page_ref.h | 8 ++++- mm/hugetlb.c | 53 ++++--------------------------------- mm/hugetlb_vmemmap.c | 16 +++++++++++ 3 files changed, 30 insertions(+), 47 deletions(-)
include/linux/page_ref.h renamed from include/linux/page_ref.h~mm-hugetlb_vmemmap-fix-race-with-speculative-pfn-walkers +7 -1
@@ -230,7 +230,13 @@ static inline int folio_ref_dec_return(sstatic inline bool page_ref_add_unless (struct page *page,int nr,int u) { -bool ret =atomic_add_unless (&page->_refcount, nr, u); +bool ret = false; + +rcu_read_lock (); +/* avoid writing to the vmemmap area being remapped */ +if (!page_is_fake_head (page) &&page_ref_count (page) != u) + ret =atomic_add_unless (&page->_refcount, nr, u); +rcu_read_unlock ();if (page_ref_tracepoint_active (page_ref_mod_unless))__page_ref_mod_unless (page, nr, ret);
mm/hugetlb.c renamed from mm/hugetlb.c~mm-hugetlb_vmemmap-fix-race-with-speculative-pfn-walkers +7 -46
111 lines not on this page · raw message
mm/hugetlb_vmemmap.c renamed from mm/hugetlb_vmemmap.c~mm-hugetlb_vmemmap-fix-race-with-speculative-pfn-walkers +16 -0
@@ -446,6 +446,8 @@ static int __hugetlb_vmemmap_restore_folunsigned long vmemmap_reuse;VM_WARN_ON_ONCE_FOLIO (!folio_test_hugetlb (folio), folio); +VM_WARN_ON_ONCE_FOLIO (folio_ref_count (folio), folio); +if (!folio_test_hugetlb_vmemmap_optimized (folio))return 0 ;
@@ -481,6 +483,9 @@ static int __hugetlb_vmemmap_restore_fol*/ int hugetlb_vmemmap_restore_folio (const struct hstate *h,struct folio *folio) { +/* avoid writes from page_ref_add_unless() while unfolding vmemmap */ +synchronize_rcu (); +return __hugetlb_vmemmap_restore_folio (h, folio,0 ); }
@@ -505,6 +510,9 @@ long hugetlb_vmemmap_restore_folios(conslong restored =0 ;long ret =0 ; +/* avoid writes from page_ref_add_unless() while unfolding vmemmap */ +synchronize_rcu (); +list_for_each_entry_safe (folio, t_folio, folio_list, lru) {if (folio_test_hugetlb_vmemmap_optimized (folio)) { ret = __hugetlb_vmemmap_restore_folio(h, folio,
@@ -550,6 +558,8 @@ static int __hugetlb_vmemmap_optimize_founsigned long vmemmap_reuse;VM_WARN_ON_ONCE_FOLIO (!folio_test_hugetlb (folio), folio); +VM_WARN_ON_ONCE_FOLIO (folio_ref_count (folio), folio); +if (!vmemmap_should_optimize_folio (h, folio))return ret;
@@ -601,6 +611,9 @@ void hugetlb_vmemmap_optimize_folio(cons {LIST_HEAD (vmemmap_pages); +/* avoid writes from page_ref_add_unless() while folding vmemmap */ +synchronize_rcu (); +__hugetlb_vmemmap_optimize_folio (h, folio, &vmemmap_pages,0 );free_vmemmap_page_list (&vmemmap_pages); }
@@ -644,6 +657,9 @@ void hugetlb_vmemmap_optimize_folios(strflush_tlb_all (); +/* avoid writes from page_ref_add_unless() while folding vmemmap */ +synchronize_rcu (); +list_for_each_entry (folio, folio_list, lru) {int ret;
_
Patches currently in -mm which might be from [email protected] are