Commit 29eea9b5 authored by Matthew Wilcox (Oracle)'s avatar Matthew Wilcox (Oracle) Committed by Andrew Morton
Browse files

mm: convert page_get_anon_vma() to folio_get_anon_vma() 

With all callers now passing in a folio, rename the function and convert
all callers.  Removes a couple of calls to compound_head() and a reference
to page->mapping.

Link: https://lkml.kernel.org/r/20220902194653.1739778-55-willy@infradead.org


Signed-off-by: default avatarMatthew Wilcox (Oracle) <willy@infradead.org>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
parent 684555aa

include/linux/rmap.h

+1 −1
Original line number Diff line number Diff line
@@ -163,7 +163,7 @@ static inline void anon_vma_merge(struct vm_area_struct *vma, 
	unlink_anon_vmas(next);

}



struct anon_vma *page_get_anon_vma(struct page *page);

struct anon_vma *folio_get_anon_vma(struct folio *folio);



/* RMAP flags, currently only relevant for some anon rmap operations. */

typedef int __bitwise rmap_t;

mm/huge_memory.c

+1 −1
Original line number Diff line number Diff line
@@ -2649,7 +2649,7 @@ int split_huge_page_to_list(struct page *page, struct list_head *list) 
		 * is taken to serialise against parallel split or collapse

		 * operations.

		 */

		anon_vma = page_get_anon_vma(&folio->page);

		anon_vma = folio_get_anon_vma(folio);

		if (!anon_vma) {

			ret = -EBUSY;

			goto out;

mm/migrate.c

+3 −3
Original line number Diff line number Diff line
@@ -1052,14 +1052,14 @@ static int __unmap_and_move(struct folio *src, struct folio *dst, 
	 * File Caches may use write_page() or lock_page() in migration, then,

	 * just care Anon page here.

	 *

	 * Only page_get_anon_vma() understands the subtleties of

	 * Only folio_get_anon_vma() understands the subtleties of

	 * getting a hold on an anon_vma from outside one of its mms.

	 * But if we cannot get anon_vma, then we won't need it anyway,

	 * because that implies that the anon page is no longer mapped

	 * (and cannot be remapped so long as we hold the page lock).

	 */

	if (folio_test_anon(src) && !folio_test_ksm(src))

		anon_vma = page_get_anon_vma(&src->page);

		anon_vma = folio_get_anon_vma(src);



	/*

	 * Block others from accessing the new page when we get around to
@@ -1298,7 +1298,7 @@ static int unmap_and_move_huge_page(new_page_t get_new_page, 
	}



	if (folio_test_anon(src))

		anon_vma = page_get_anon_vma(&src->page);

		anon_vma = folio_get_anon_vma(src);



	if (unlikely(!folio_trylock(dst)))

		goto put_anon;

mm/rmap.c

+7 −7
Original line number Diff line number Diff line
@@ -486,16 +486,16 @@ void __init anon_vma_init(void) 
 * if there is a mapcount, we can dereference the anon_vma after observing

 * those.

 */

struct anon_vma *page_get_anon_vma(struct page *page)

struct anon_vma *folio_get_anon_vma(struct folio *folio)

{

	struct anon_vma *anon_vma = NULL;

	unsigned long anon_mapping;



	rcu_read_lock();

	anon_mapping = (unsigned long)READ_ONCE(page->mapping);

	anon_mapping = (unsigned long)READ_ONCE(folio->mapping);

	if ((anon_mapping & PAGE_MAPPING_FLAGS) != PAGE_MAPPING_ANON)

		goto out;

	if (!page_mapped(page))

	if (!folio_mapped(folio))

		goto out;



	anon_vma = (struct anon_vma *) (anon_mapping - PAGE_MAPPING_ANON);
@@ -505,13 +505,13 @@ struct anon_vma *page_get_anon_vma(struct page *page) 
	}



	/*

	 * If this page is still mapped, then its anon_vma cannot have been

	 * If this folio is still mapped, then its anon_vma cannot have been

	 * freed.  But if it has been unmapped, we have no security against the

	 * anon_vma structure being freed and reused (for another anon_vma:

	 * SLAB_TYPESAFE_BY_RCU guarantees that - so the atomic_inc_not_zero()

	 * above cannot corrupt).

	 */

	if (!page_mapped(page)) {

	if (!folio_mapped(folio)) {

		rcu_read_unlock();

		put_anon_vma(anon_vma);

		return NULL;
@@ -523,11 +523,11 @@ struct anon_vma *page_get_anon_vma(struct page *page) 
}



/*

 * Similar to page_get_anon_vma() except it locks the anon_vma.

 * Similar to folio_get_anon_vma() except it locks the anon_vma.

 *

 * Its a little more complex as it tries to keep the fast path to a single

 * atomic op -- the trylock. If we fail the trylock, we fall back to getting a

 * reference like with page_get_anon_vma() and then block on the mutex

 * reference like with folio_get_anon_vma() and then block on the mutex

 * on !rwc->try_lock case.

 */

struct anon_vma *folio_lock_anon_vma_read(struct folio *folio,