[RFC PATCH 08/19] mm: hugetlb: Refactor restore_reserve_on_error

[Ackerley Tng]

Refactor restore_reserve_on_error to allow resv_map to be passed
in. vma_resv_map() assumes the use of hugetlbfs in the way it
retrieves the resv_map from the vma and inode.

Introduce restore_reserve_on_error_vma() which retains original
functionality to simplify refactoring for now.

Signed-off-by: Ackerley Tng <ackerleytng@google.com>
---
 fs/hugetlbfs/inode.c    |  2 +-
 include/linux/hugetlb.h |  6 ++++--
 mm/hugetlb.c            | 37 +++++++++++++++++++++----------------
 3 files changed, 26 insertions(+), 19 deletions(-)

diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c
index 0fc49b6252e4..44e6ee9a856d 100644
--- a/fs/hugetlbfs/inode.c
+++ b/fs/hugetlbfs/inode.c
@@ -868,7 +868,7 @@ static long hugetlbfs_fallocate(struct file *file, int 
mode, loff_t offset,
                __folio_mark_uptodate(folio);
                error = hugetlb_add_to_page_cache(folio, mapping, index);
                if (unlikely(error)) {
-                       restore_reserve_on_error(h, &pseudo_vma, addr, folio);
+                       restore_reserve_on_error_vma(h, &pseudo_vma, addr, 
folio);
                        folio_put(folio);
                        mutex_unlock(&hugetlb_fault_mutex_table[hash]);
                        goto out;
diff --git a/include/linux/hugetlb.h b/include/linux/hugetlb.h
index 7d49048c5a2a..02a2766d89a4 100644
--- a/include/linux/hugetlb.h
+++ b/include/linux/hugetlb.h
@@ -760,8 +760,10 @@ int hugetlb_filemap_add_folio(struct address_space 
*mapping, struct hstate *h,
                              struct folio *folio, pgoff_t idx);
 int hugetlb_add_to_page_cache(struct folio *folio, struct address_space 
*mapping,
                        pgoff_t idx);
-void restore_reserve_on_error(struct hstate *h, struct vm_area_struct *vma,
-                               unsigned long address, struct folio *folio);
+void restore_reserve_on_error(struct resv_map *resv, pgoff_t resv_index,
+                             bool may_share, struct folio *folio);
+void restore_reserve_on_error_vma(struct hstate *h, struct vm_area_struct *vma,
+                                 unsigned long address, struct folio *folio);
 
 /* arch callback */
 int __init __alloc_bootmem_huge_page(struct hstate *h, int nid);
diff --git a/mm/hugetlb.c b/mm/hugetlb.c
index d943f83d15a9..4675f9efeba4 100644
--- a/mm/hugetlb.c
+++ b/mm/hugetlb.c
@@ -2805,15 +2805,10 @@ static long resv_map_del_reservation(struct resv_map 
*resv, pgoff_t resv_index,
  *
  * In case 2, simply undo reserve map modifications done by 
alloc_hugetlb_folio.
  */
-void restore_reserve_on_error(struct hstate *h, struct vm_area_struct *vma,
-                       unsigned long address, struct folio *folio)
+void restore_reserve_on_error(struct resv_map *resv, pgoff_t resv_index,
+                             bool may_share, struct folio *folio)
 {
-       long rc;
-       struct resv_map *resv = vma_resv_map(vma);
-       pgoff_t resv_index = vma_hugecache_offset(h, vma, address);
-       bool may_share = vma->vm_flags & VM_MAYSHARE;
-
-       rc = resv_map_needs_reservation(resv, resv_index, may_share);
+       long rc = resv_map_needs_reservation(resv, resv_index, may_share);
 
        if (folio_test_hugetlb_restore_reserve(folio)) {
                if (unlikely(rc < 0))
@@ -2865,7 +2860,7 @@ void restore_reserve_on_error(struct hstate *h, struct 
vm_area_struct *vma,
                         * For shared mappings, no entry in the map indicates
                         * no reservation.  We are done.
                         */
-                       if (!(vma->vm_flags & VM_MAYSHARE))
+                       if (!may_share)
                                /*
                                 * For private mappings, no entry indicates
                                 * a reservation is present.  Since we can
@@ -2883,6 +2878,16 @@ void restore_reserve_on_error(struct hstate *h, struct 
vm_area_struct *vma,
        }
 }
 
+void restore_reserve_on_error_vma(struct hstate *h, struct vm_area_struct *vma,
+                                 unsigned long address, struct folio *folio)
+{
+       struct resv_map *resv = vma_resv_map(vma);
+       pgoff_t resv_index = vma_hugecache_offset(h, vma, address);
+       bool may_share = vma->vm_flags & VM_MAYSHARE;
+
+       restore_reserve_on_error(resv, resv_index, may_share, folio);
+}
+
 /*
  * alloc_and_dissolve_hugetlb_folio - Allocate a new folio and dissolve
  * the old one
@@ -5109,8 +5114,8 @@ int copy_hugetlb_page_range(struct mm_struct *dst, struct 
mm_struct *src,
                                spin_lock_nested(src_ptl, SINGLE_DEPTH_NESTING);
                                entry = huge_ptep_get(src_pte);
                                if (!pte_same(src_pte_old, entry)) {
-                                       restore_reserve_on_error(h, dst_vma, 
addr,
-                                                               new_folio);
+                                       restore_reserve_on_error_vma(h, 
dst_vma, addr,
+                                                                    new_folio);
                                        folio_put(new_folio);
                                        /* huge_ptep of dst_pte won't change as 
in child */
                                        goto again;
@@ -5642,7 +5647,7 @@ static vm_fault_t hugetlb_wp(struct mm_struct *mm, struct 
vm_area_struct *vma,
         * unshare)
         */
        if (new_folio != page_folio(old_page))
-               restore_reserve_on_error(h, vma, haddr, new_folio);
+               restore_reserve_on_error_vma(h, vma, haddr, new_folio);
        folio_put(new_folio);
 out_release_old:
        put_page(old_page);
@@ -5860,7 +5865,7 @@ static vm_fault_t hugetlb_no_page(struct mm_struct *mm,
                                 * to the page cache. So it's safe to call
                                 * restore_reserve_on_error() here.
                                 */
-                               restore_reserve_on_error(h, vma, haddr, folio);
+                               restore_reserve_on_error_vma(h, vma, haddr, 
folio);
                                folio_put(folio);
                                goto out;
                        }
@@ -5965,7 +5970,7 @@ static vm_fault_t hugetlb_no_page(struct mm_struct *mm,
        spin_unlock(ptl);
 backout_unlocked:
        if (new_folio && !new_pagecache_folio)
-               restore_reserve_on_error(h, vma, haddr, folio);
+               restore_reserve_on_error_vma(h, vma, haddr, folio);
 
        folio_unlock(folio);
        folio_put(folio);
@@ -6232,7 +6237,7 @@ int hugetlb_mcopy_atomic_pte(struct mm_struct *dst_mm,
                        /* Free the allocated folio which may have
                         * consumed a reservation.
                         */
-                       restore_reserve_on_error(h, dst_vma, dst_addr, folio);
+                       restore_reserve_on_error_vma(h, dst_vma, dst_addr, 
folio);
                        folio_put(folio);
 
                        /* Allocate a temporary folio to hold the copied
@@ -6361,7 +6366,7 @@ int hugetlb_mcopy_atomic_pte(struct mm_struct *dst_mm,
                folio_unlock(folio);
 out_release_nounlock:
        if (!folio_in_pagecache)
-               restore_reserve_on_error(h, dst_vma, dst_addr, folio);
+               restore_reserve_on_error_vma(h, dst_vma, dst_addr, folio);
        folio_put(folio);
        goto out;
 }
-- 
2.41.0.rc0.172.g3f132b7071-goog