LKML Archive on lore.kernel.org
help / color / mirror / Atom feed
* [PATCH v4] mm/migrate.c: Rework migration_entry_wait() to not take a pageref
@ 2021-11-18  2:07 Alistair Popple
  2021-11-22 18:15 ` David Hildenbrand
  0 siblings, 1 reply; 3+ messages in thread
From: Alistair Popple @ 2021-11-18  2:07 UTC (permalink / raw)
  To: akpm
  Cc: willy, dhowells, hughd, linux-kernel, linux-mm, jglisse, jgg,
	rcampbell, jhubbard, Alistair Popple

This fixes the FIXME in migrate_vma_check_page().

Before migrating a page migration code will take a reference and check
there are no unexpected page references, failing the migration if there
are. When a thread faults on a migration entry it will take a temporary
reference to the page to wait for the page to become unlocked signifying
the migration entry has been removed.

This reference is dropped just prior to waiting on the page lock,
however the extra reference can cause migration failures so it is
desirable to avoid taking it.

As migration code already has a reference to the migrating page an extra
reference to wait on PG_locked is unnecessary so long as the reference
can't be dropped whilst setting up the wait.

When faulting on a migration entry the ptl is taken to check the
migration entry. Removing a migration entry also requires the ptl, and
migration code won't drop its page reference until after the migration
entry has been removed. Therefore retaining the ptl of a migration entry
is sufficient to ensure the page has a reference. Reworking
migration_entry_wait() to hold the ptl until the wait setup is complete
means the extra page reference is no longer needed.

Signed-off-by: Alistair Popple <apopple@nvidia.com>

---

v4:
 - Fixed compiler warning
 - Updated comments/description missed during page -> folio rebase

v3:
 - Fix a build issue for CONFIG_MMU=n by only building
   migration_entry_wait_on_locked() if CONFIG_MIGRATION=y

v2:
 - Rebase to master with folios
 - Avoid taking a pageref in pmd_migration_entry_wait() as well
---
 include/linux/migrate.h |  2 +
 mm/filemap.c            | 88 +++++++++++++++++++++++++++++++++++++++++
 mm/migrate.c            | 33 ++--------------
 3 files changed, 94 insertions(+), 29 deletions(-)

diff --git a/include/linux/migrate.h b/include/linux/migrate.h
index 4850cc5bf813..54579902ec9f 100644
--- a/include/linux/migrate.h
+++ b/include/linux/migrate.h
@@ -40,6 +40,8 @@ extern int migrate_huge_page_move_mapping(struct address_space *mapping,
 				  struct page *newpage, struct page *page);
 extern int migrate_page_move_mapping(struct address_space *mapping,
 		struct page *newpage, struct page *page, int extra_count);
+void migration_entry_wait_on_locked(struct folio *folio, pte_t *ptep,
+				spinlock_t *ptl);
 void folio_migrate_flags(struct folio *newfolio, struct folio *folio);
 void folio_migrate_copy(struct folio *newfolio, struct folio *folio);
 int folio_migrate_mapping(struct address_space *mapping,
diff --git a/mm/filemap.c b/mm/filemap.c
index daa0e23a6ee6..fa522f11e74d 100644
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -41,6 +41,7 @@
 #include <linux/psi.h>
 #include <linux/ramfs.h>
 #include <linux/page_idle.h>
+#include <linux/migrate.h>
 #include <asm/pgalloc.h>
 #include <asm/tlbflush.h>
 #include "internal.h"
@@ -1426,6 +1427,93 @@ static inline int folio_wait_bit_common(struct folio *folio, int bit_nr,
 	return wait->flags & WQ_FLAG_WOKEN ? 0 : -EINTR;
 }
 
+#ifdef CONFIG_MIGRATION
+/**
+ * migration_entry_wait_on_locked - Wait for a migration entry to be removed
+ * @folio: folio referenced by the migration entry.
+ * @ptep: mapped pte pointer. This function will return with the ptep unmapped.
+ * @ptl: already locked ptl. This function will drop the lock.
+ *
+ * Wait for a migration entry referencing the given page to be removed. This is
+ * equivalent to put_and_wait_on_page_locked(page, TASK_UNINTERRUPTIBLE) except
+ * this can be called without taking a reference on the page. Instead this
+ * should be called while holding the ptl for the migration entry referencing
+ * the page.
+ *
+ * Returns after unmapping and unlocking the pte/ptl with pte_unmap_unlock().
+ *
+ * This follows the same logic as wait_on_page_bit_common() so see the comments
+ * there.
+ */
+void migration_entry_wait_on_locked(struct folio *folio, pte_t *ptep,
+				spinlock_t *ptl)
+{
+	struct wait_page_queue wait_page;
+	wait_queue_entry_t *wait = &wait_page.wait;
+	bool thrashing = false;
+	bool delayacct = false;
+	unsigned long pflags;
+	wait_queue_head_t *q;
+
+	q = folio_waitqueue(folio);
+	if (!folio_test_uptodate(folio) && folio_test_workingset(folio)) {
+		if (!folio_test_swapbacked(folio)) {
+			delayacct_thrashing_start();
+			delayacct = true;
+		}
+		psi_memstall_enter(&pflags);
+		thrashing = true;
+	}
+
+	init_wait(wait);
+	wait->func = wake_page_function;
+	wait_page.folio = folio;
+	wait_page.bit_nr = PG_locked;
+	wait->flags = 0;
+
+	spin_lock_irq(&q->lock);
+	folio_set_waiters(folio);
+	if (!folio_trylock_flag(folio, PG_locked, wait))
+		__add_wait_queue_entry_tail(q, wait);
+	spin_unlock_irq(&q->lock);
+
+	/*
+	 * If a migration entry exists for the page the migration path must hold
+	 * a valid reference to the page, and it must take the ptl to remove the
+	 * migration entry. So the page is valid until the ptl is dropped.
+	 */
+	if (ptep)
+		pte_unmap_unlock(ptep, ptl);
+	else
+		spin_unlock(ptl);
+
+	for (;;) {
+		unsigned int flags;
+
+		set_current_state(TASK_UNINTERRUPTIBLE);
+
+		/* Loop until we've been woken or interrupted */
+		flags = smp_load_acquire(&wait->flags);
+		if (!(flags & WQ_FLAG_WOKEN)) {
+			if (signal_pending_state(TASK_UNINTERRUPTIBLE, current))
+				break;
+
+			io_schedule();
+			continue;
+		}
+		break;
+	}
+
+	finish_wait(q, wait);
+
+	if (thrashing) {
+		if (delayacct)
+			delayacct_thrashing_end();
+		psi_memstall_leave(&pflags);
+	}
+}
+#endif
+
 void folio_wait_bit(struct folio *folio, int bit_nr)
 {
 	folio_wait_bit_common(folio, bit_nr, TASK_UNINTERRUPTIBLE, SHARED);
diff --git a/mm/migrate.c b/mm/migrate.c
index cf25b00f03c8..8d29a7903f9e 100644
--- a/mm/migrate.c
+++ b/mm/migrate.c
@@ -305,15 +305,7 @@ void __migration_entry_wait(struct mm_struct *mm, pte_t *ptep,
 	page = pfn_swap_entry_to_page(entry);
 	page = compound_head(page);
 
-	/*
-	 * Once page cache replacement of page migration started, page_count
-	 * is zero; but we must not call put_and_wait_on_page_locked() without
-	 * a ref. Use get_page_unless_zero(), and just fault again if it fails.
-	 */
-	if (!get_page_unless_zero(page))
-		goto out;
-	pte_unmap_unlock(ptep, ptl);
-	put_and_wait_on_page_locked(page, TASK_UNINTERRUPTIBLE);
+	migration_entry_wait_on_locked(page_folio(page), ptep, ptl);
 	return;
 out:
 	pte_unmap_unlock(ptep, ptl);
@@ -344,10 +336,7 @@ void pmd_migration_entry_wait(struct mm_struct *mm, pmd_t *pmd)
 	if (!is_pmd_migration_entry(*pmd))
 		goto unlock;
 	page = pfn_swap_entry_to_page(pmd_to_swp_entry(*pmd));
-	if (!get_page_unless_zero(page))
-		goto unlock;
-	spin_unlock(ptl);
-	put_and_wait_on_page_locked(page, TASK_UNINTERRUPTIBLE);
+	migration_entry_wait_on_locked(page_folio(page), NULL, ptl);
 	return;
 unlock:
 	spin_unlock(ptl);
@@ -2484,22 +2473,8 @@ static bool migrate_vma_check_page(struct page *page)
 		return false;
 
 	/* Page from ZONE_DEVICE have one extra reference */
-	if (is_zone_device_page(page)) {
-		/*
-		 * Private page can never be pin as they have no valid pte and
-		 * GUP will fail for those. Yet if there is a pending migration
-		 * a thread might try to wait on the pte migration entry and
-		 * will bump the page reference count. Sadly there is no way to
-		 * differentiate a regular pin from migration wait. Hence to
-		 * avoid 2 racing thread trying to migrate back to CPU to enter
-		 * infinite loop (one stopping migration because the other is
-		 * waiting on pte migration entry). We always return true here.
-		 *
-		 * FIXME proper solution is to rework migration_entry_wait() so
-		 * it does not need to take a reference on page.
-		 */
-		return is_device_private_page(page);
-	}
+	if (is_zone_device_page(page))
+		extra++;
 
 	/* For file back page */
 	if (page_mapping(page))
-- 
2.30.2


^ permalink raw reply	[flat|nested] 3+ messages in thread

* Re: [PATCH v4] mm/migrate.c: Rework migration_entry_wait() to not take a pageref
  2021-11-18  2:07 [PATCH v4] mm/migrate.c: Rework migration_entry_wait() to not take a pageref Alistair Popple
@ 2021-11-22 18:15 ` David Hildenbrand
  2021-11-22 23:28   ` Alistair Popple
  0 siblings, 1 reply; 3+ messages in thread
From: David Hildenbrand @ 2021-11-22 18:15 UTC (permalink / raw)
  To: Alistair Popple, akpm
  Cc: willy, dhowells, hughd, linux-kernel, linux-mm, jglisse, jgg,
	rcampbell, jhubbard

On 18.11.21 03:07, Alistair Popple wrote:
> This fixes the FIXME in migrate_vma_check_page().
> 
> Before migrating a page migration code will take a reference and check
> there are no unexpected page references, failing the migration if there
> are. When a thread faults on a migration entry it will take a temporary
> reference to the page to wait for the page to become unlocked signifying
> the migration entry has been removed.
> 
> This reference is dropped just prior to waiting on the page lock,
> however the extra reference can cause migration failures so it is
> desirable to avoid taking it.
> 
> As migration code already has a reference to the migrating page an extra
> reference to wait on PG_locked is unnecessary so long as the reference
> can't be dropped whilst setting up the wait.
> 
> When faulting on a migration entry the ptl is taken to check the
> migration entry. Removing a migration entry also requires the ptl, and
> migration code won't drop its page reference until after the migration
> entry has been removed. Therefore retaining the ptl of a migration entry
> is sufficient to ensure the page has a reference. Reworking
> migration_entry_wait() to hold the ptl until the wait setup is complete
> means the extra page reference is no longer needed.
> 

I really like this, thanks for this work!

[...]

> +#ifdef CONFIG_MIGRATION
> +/**
> + * migration_entry_wait_on_locked - Wait for a migration entry to be removed
> + * @folio: folio referenced by the migration entry.
> + * @ptep: mapped pte pointer. This function will return with the ptep unmapped.
> + * @ptl: already locked ptl. This function will drop the lock.
> + *
> + * Wait for a migration entry referencing the given page to be removed. This is
> + * equivalent to put_and_wait_on_page_locked(page, TASK_UNINTERRUPTIBLE) except
> + * this can be called without taking a reference on the page. Instead this
> + * should be called while holding the ptl for the migration entry referencing
> + * the page.
> + *
> + * Returns after unmapping and unlocking the pte/ptl with pte_unmap_unlock().

You could maybe make it clear that callers have to pass the ptep only
for PTE migration entries. For a PMD migration entry, pass NULL.

> + *
> + * This follows the same logic as wait_on_page_bit_common() so see the comments

s/wait_on_page_bit_common/folio_wait_bit_common/ ?

> + * there.
> + */
> +void migration_entry_wait_on_locked(struct folio *folio, pte_t *ptep,
> +				spinlock_t *ptl)
> +{
> +	struct wait_page_queue wait_page;
> +	wait_queue_entry_t *wait = &wait_page.wait;
> +	bool thrashing = false;
> +	bool delayacct = false;
> +	unsigned long pflags;
> +	wait_queue_head_t *q;
> +
> +	q = folio_waitqueue(folio);
> +	if (!folio_test_uptodate(folio) && folio_test_workingset(folio)) {
> +		if (!folio_test_swapbacked(folio)) {
> +			delayacct_thrashing_start();
> +			delayacct = true;
> +		}
> +		psi_memstall_enter(&pflags);
> +		thrashing = true;
> +	}
> +
> +	init_wait(wait);
> +	wait->func = wake_page_function;
> +	wait_page.folio = folio;
> +	wait_page.bit_nr = PG_locked;
> +	wait->flags = 0;
> +
> +	spin_lock_irq(&q->lock);
> +	folio_set_waiters(folio);
> +	if (!folio_trylock_flag(folio, PG_locked, wait))
> +		__add_wait_queue_entry_tail(q, wait);
> +	spin_unlock_irq(&q->lock);
> +
> +	/*
> +	 * If a migration entry exists for the page the migration path must hold
> +	 * a valid reference to the page, and it must take the ptl to remove the
> +	 * migration entry. So the page is valid until the ptl is dropped.
> +	 */
> +	if (ptep)
> +		pte_unmap_unlock(ptep, ptl);
> +	else
> +		spin_unlock(ptl);
> +
> +	for (;;) {
> +		unsigned int flags;
> +
> +		set_current_state(TASK_UNINTERRUPTIBLE);
> +
> +		/* Loop until we've been woken or interrupted */
> +		flags = smp_load_acquire(&wait->flags);
> +		if (!(flags & WQ_FLAG_WOKEN)) {
> +			if (signal_pending_state(TASK_UNINTERRUPTIBLE, current))
> +				break;
> +
> +			io_schedule();
> +			continue;
> +		}
> +		break;
> +	}
> +
> +	finish_wait(q, wait);
> +
> +	if (thrashing) {
> +		if (delayacct)
> +			delayacct_thrashing_end();
> +		psi_memstall_leave(&pflags);
> +	}
> +}
> +#endif
> +

I'm fairly new to the glory details of core migration entry and page bit
waiting code, but it makes sense to me and removing the temporary extra
references is very nice! Feel free to add my

Acked-by: David Hildenbrand <david@redhat.com>

-- 
Thanks,

David / dhildenb


^ permalink raw reply	[flat|nested] 3+ messages in thread

* Re: [PATCH v4] mm/migrate.c: Rework migration_entry_wait() to not take a pageref
  2021-11-22 18:15 ` David Hildenbrand
@ 2021-11-22 23:28   ` Alistair Popple
  0 siblings, 0 replies; 3+ messages in thread
From: Alistair Popple @ 2021-11-22 23:28 UTC (permalink / raw)
  To: akpm, David Hildenbrand
  Cc: willy, dhowells, hughd, linux-kernel, linux-mm, jglisse, jgg,
	rcampbell, jhubbard

On Tuesday, 23 November 2021 5:15:27 AM AEDT David Hildenbrand wrote:

[...]

> > +#ifdef CONFIG_MIGRATION
> > +/**
> > + * migration_entry_wait_on_locked - Wait for a migration entry to be removed
> > + * @folio: folio referenced by the migration entry.
> > + * @ptep: mapped pte pointer. This function will return with the ptep unmapped.
> > + * @ptl: already locked ptl. This function will drop the lock.
> > + *
> > + * Wait for a migration entry referencing the given page to be removed. This is
> > + * equivalent to put_and_wait_on_page_locked(page, TASK_UNINTERRUPTIBLE) except
> > + * this can be called without taking a reference on the page. Instead this
> > + * should be called while holding the ptl for the migration entry referencing
> > + * the page.
> > + *
> > + * Returns after unmapping and unlocking the pte/ptl with pte_unmap_unlock().
> 
> You could maybe make it clear that callers have to pass the ptep only
> for PTE migration entries. For a PMD migration entry, pass NULL.

Will do.
 
> > + *
> > + * This follows the same logic as wait_on_page_bit_common() so see the comments
> 
> s/wait_on_page_bit_common/folio_wait_bit_common/ ?

Evidently this escaped my s// when rebasing on top of folio's. Will fix.

> > + * there.
> > + */
> > +void migration_entry_wait_on_locked(struct folio *folio, pte_t *ptep,
> > +				spinlock_t *ptl)
> > +{
> > +	struct wait_page_queue wait_page;
> > +	wait_queue_entry_t *wait = &wait_page.wait;
> > +	bool thrashing = false;
> > +	bool delayacct = false;
> > +	unsigned long pflags;
> > +	wait_queue_head_t *q;
> > +
> > +	q = folio_waitqueue(folio);
> > +	if (!folio_test_uptodate(folio) && folio_test_workingset(folio)) {
> > +		if (!folio_test_swapbacked(folio)) {
> > +			delayacct_thrashing_start();
> > +			delayacct = true;
> > +		}
> > +		psi_memstall_enter(&pflags);
> > +		thrashing = true;
> > +	}
> > +
> > +	init_wait(wait);
> > +	wait->func = wake_page_function;
> > +	wait_page.folio = folio;
> > +	wait_page.bit_nr = PG_locked;
> > +	wait->flags = 0;
> > +
> > +	spin_lock_irq(&q->lock);
> > +	folio_set_waiters(folio);
> > +	if (!folio_trylock_flag(folio, PG_locked, wait))
> > +		__add_wait_queue_entry_tail(q, wait);
> > +	spin_unlock_irq(&q->lock);
> > +
> > +	/*
> > +	 * If a migration entry exists for the page the migration path must hold
> > +	 * a valid reference to the page, and it must take the ptl to remove the
> > +	 * migration entry. So the page is valid until the ptl is dropped.
> > +	 */
> > +	if (ptep)
> > +		pte_unmap_unlock(ptep, ptl);
> > +	else
> > +		spin_unlock(ptl);
> > +
> > +	for (;;) {
> > +		unsigned int flags;
> > +
> > +		set_current_state(TASK_UNINTERRUPTIBLE);
> > +
> > +		/* Loop until we've been woken or interrupted */
> > +		flags = smp_load_acquire(&wait->flags);
> > +		if (!(flags & WQ_FLAG_WOKEN)) {
> > +			if (signal_pending_state(TASK_UNINTERRUPTIBLE, current))
> > +				break;
> > +
> > +			io_schedule();
> > +			continue;
> > +		}
> > +		break;
> > +	}
> > +
> > +	finish_wait(q, wait);
> > +
> > +	if (thrashing) {
> > +		if (delayacct)
> > +			delayacct_thrashing_end();
> > +		psi_memstall_leave(&pflags);
> > +	}
> > +}
> > +#endif
> > +
> 
> I'm fairly new to the glory details of core migration entry and page bit
> waiting code, but it makes sense to me and removing the temporary extra
> references is very nice! Feel free to add my
> 
> Acked-by: David Hildenbrand <david@redhat.com>

Thanks for taking a look, really appreciate it!

 - Alistair




^ permalink raw reply	[flat|nested] 3+ messages in thread

end of thread, other threads:[~2021-11-22 23:29 UTC | newest]

Thread overview: 3+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2021-11-18  2:07 [PATCH v4] mm/migrate.c: Rework migration_entry_wait() to not take a pageref Alistair Popple
2021-11-22 18:15 ` David Hildenbrand
2021-11-22 23:28   ` Alistair Popple

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).