[PATCH RFC 10/11] mm/migrate: pass migrate_control to migrate_pages()

[Shivank Garg <shivankg@amd.com>]

migrate_pages() still takes mode and reason separately and reconstructs a
migrate_control internally. This prevents callers from supplying additional
migration policy without extending its argument list.

Change migrate_pages() to take a const struct migrate_control pointer and
update callers to construct it on the stack. Derive asynchronous controls
by copying the caller's control and overriding only the mode, preserving
any additional policy fields.

No functional change intended.

Signed-off-by: Shivank Garg <shivankg@amd.com>
---
 include/linux/migrate.h |  5 ++---
 mm/compaction.c         |  8 ++++++--
 mm/damon/ops-common.c   |  7 +++++--
 mm/gup.c                |  7 +++++--
 mm/memory-failure.c     |  6 +++++-
 mm/memory_hotplug.c     |  6 +++++-
 mm/mempolicy.c          | 13 ++++++++++---
 mm/migrate.c            | 36 +++++++++++++++++++-----------------
 mm/page_alloc.c         |  6 +++++-
 mm/vmscan.c             |  7 +++++--
 10 files changed, 67 insertions(+), 34 deletions(-)

diff --git a/include/linux/migrate.h b/include/linux/migrate.h
index 78424b3824c2..cec5713944e3 100644
--- a/include/linux/migrate.h
+++ b/include/linux/migrate.h
@@ -57,8 +57,7 @@ void putback_movable_pages(struct list_head *l);
 int migrate_folio(struct address_space *mapping, struct folio *dst,
 		struct folio *src, enum migrate_mode mode);
 int migrate_pages(struct list_head *l, new_folio_t new, free_folio_t free,
-		unsigned long private, enum migrate_mode mode,
-		enum migrate_reason reason,
+		unsigned long private, const struct migrate_control *ctl,
 		unsigned int *ret_succeeded);
 struct folio *alloc_migration_target(struct folio *src, unsigned long private);
 bool isolate_movable_ops_page(struct page *page, isolate_mode_t mode);
@@ -78,7 +77,7 @@ int set_movable_ops(const struct movable_operations *ops, enum pagetype type);
 static inline void putback_movable_pages(struct list_head *l) {}
 static inline int migrate_pages(struct list_head *l, new_folio_t new,
 		free_folio_t free, unsigned long private,
-		enum migrate_mode mode, enum migrate_reason reason,
+		const struct migrate_control *ctl,
 		unsigned int *ret_succeeded)
 	{ return -ENOSYS; }
 static inline struct folio *alloc_migration_target(struct folio *src,
diff --git a/mm/compaction.c b/mm/compaction.c
index a049415512c6..e75fcb0ee007 100644
--- a/mm/compaction.c
+++ b/mm/compaction.c
@@ -2566,6 +2566,10 @@ compact_zone(struct compact_control *cc, struct capture_control *capc)
 	unsigned long end_pfn = zone_end_pfn(cc->zone);
 	unsigned long last_migrated_pfn;
 	const bool sync = cc->mode != MIGRATE_ASYNC;
+	const struct migrate_control ctl = {
+		.mode = cc->mode,
+		.reason = MR_COMPACTION,
+	};
 	bool update_cached;
 	unsigned int nr_succeeded = 0, nr_migratepages;
 	int order;
@@ -2696,8 +2700,8 @@ compact_zone(struct compact_control *cc, struct capture_control *capc)
 		 */
 		nr_migratepages = cc->nr_migratepages;
 		err = migrate_pages(&cc->migratepages, compaction_alloc,
-				compaction_free, (unsigned long)cc, cc->mode,
-				MR_COMPACTION, &nr_succeeded);
+				compaction_free, (unsigned long)cc, &ctl,
+				&nr_succeeded);
 
 		trace_mm_compaction_migratepages(nr_migratepages, nr_succeeded);
 
diff --git a/mm/damon/ops-common.c b/mm/damon/ops-common.c
index fbda70d8ea4d..da848561aebb 100644
--- a/mm/damon/ops-common.c
+++ b/mm/damon/ops-common.c
@@ -315,6 +315,10 @@ static unsigned int __damon_migrate_folio_list(
 			__GFP_NOMEMALLOC | GFP_NOWAIT | __GFP_THISNODE,
 		.nid = target_nid,
 	};
+	const struct migrate_control ctl = {
+		.mode = MIGRATE_ASYNC,
+		.reason = MR_DAMON,
+	};
 
 	if (pgdat->node_id == target_nid || target_nid == NUMA_NO_NODE)
 		return 0;
@@ -324,8 +328,7 @@ static unsigned int __damon_migrate_folio_list(
 
 	/* Migration ignores all cpuset and mempolicy settings */
 	migrate_pages(migrate_folios, alloc_migration_target, NULL,
-		      (unsigned long)&mtc, MIGRATE_ASYNC, MR_DAMON,
-		      &nr_succeeded);
+		      (unsigned long)&mtc, &ctl, &nr_succeeded);
 
 	return nr_succeeded;
 }
diff --git a/mm/gup.c b/mm/gup.c
index eb898ea1ee22..73e1e8bfa4c0 100644
--- a/mm/gup.c
+++ b/mm/gup.c
@@ -2357,10 +2357,13 @@ migrate_longterm_unpinnable_folios(struct list_head *movable_folio_list,
 			.gfp_mask = GFP_USER | __GFP_NOWARN,
 			.reason = MR_LONGTERM_PIN,
 		};
+		const struct migrate_control ctl = {
+			.mode = MIGRATE_SYNC,
+			.reason = MR_LONGTERM_PIN,
+		};
 
 		if (migrate_pages(movable_folio_list, alloc_migration_target,
-				  NULL, (unsigned long)&mtc, MIGRATE_SYNC,
-				  MR_LONGTERM_PIN, NULL)) {
+				  NULL, (unsigned long)&mtc, &ctl, NULL)) {
 			ret = -ENOMEM;
 			goto err;
 		}
diff --git a/mm/memory-failure.c b/mm/memory-failure.c
index a8b03e2920ba..85d0a69a0844 100644
--- a/mm/memory-failure.c
+++ b/mm/memory-failure.c
@@ -2860,6 +2860,10 @@ static int soft_offline_in_use_page(struct page *page)
 		.gfp_mask = GFP_USER | __GFP_MOVABLE | __GFP_RETRY_MAYFAIL,
 		.reason = MR_MEMORY_FAILURE,
 	};
+	const struct migrate_control ctl = {
+		.mode = MIGRATE_SYNC,
+		.reason = MR_MEMORY_FAILURE,
+	};
 
 	if (!huge && folio_test_large(folio)) {
 		const int new_order = min_order_for_split(folio);
@@ -2916,7 +2920,7 @@ static int soft_offline_in_use_page(struct page *page)
 
 	if (isolated) {
 		ret = migrate_pages(&pagelist, alloc_migration_target, NULL,
-			(unsigned long)&mtc, MIGRATE_SYNC, MR_MEMORY_FAILURE, NULL);
+			(unsigned long)&mtc, &ctl, NULL);
 		if (!ret) {
 			bool release = !huge;
 
diff --git a/mm/memory_hotplug.c b/mm/memory_hotplug.c
index 226ab9cb078a..1250b0d47702 100644
--- a/mm/memory_hotplug.c
+++ b/mm/memory_hotplug.c
@@ -1901,6 +1901,10 @@ static void do_migrate_range(unsigned long start_pfn, unsigned long end_pfn)
 			.gfp_mask = GFP_KERNEL | __GFP_MOVABLE | __GFP_RETRY_MAYFAIL,
 			.reason = MR_MEMORY_HOTPLUG,
 		};
+		const struct migrate_control ctl = {
+			.mode = MIGRATE_SYNC,
+			.reason = MR_MEMORY_HOTPLUG,
+		};
 		int ret;
 
 		/*
@@ -1918,7 +1922,7 @@ static void do_migrate_range(unsigned long start_pfn, unsigned long end_pfn)
 		if (nodes_empty(nmask))
 			node_set(mtc.nid, nmask);
 		ret = migrate_pages(&source, alloc_migration_target, NULL,
-			(unsigned long)&mtc, MIGRATE_SYNC, MR_MEMORY_HOTPLUG, NULL);
+			(unsigned long)&mtc, &ctl, NULL);
 		if (ret) {
 			list_for_each_entry(folio, &source, lru) {
 				if (__ratelimit(&migrate_rs)) {
diff --git a/mm/mempolicy.c b/mm/mempolicy.c
index 3498a5651d50..14f3f24a6fad 100644
--- a/mm/mempolicy.c
+++ b/mm/mempolicy.c
@@ -1295,6 +1295,10 @@ static long migrate_to_node(struct mm_struct *mm, int source, int dest,
 		.gfp_mask = GFP_HIGHUSER_MOVABLE | __GFP_THISNODE,
 		.reason = MR_SYSCALL,
 	};
+	const struct migrate_control ctl = {
+		.mode = MIGRATE_SYNC,
+		.reason = MR_SYSCALL,
+	};
 
 	nodes_clear(nmask);
 	node_set(source, nmask);
@@ -1320,7 +1324,7 @@ static long migrate_to_node(struct mm_struct *mm, int source, int dest,
 
 	if (!list_empty(&pagelist)) {
 		err = migrate_pages(&pagelist, alloc_migration_target, NULL,
-			(unsigned long)&mtc, MIGRATE_SYNC, MR_SYSCALL, NULL);
+			(unsigned long)&mtc, &ctl, NULL);
 		if (err)
 			putback_movable_pages(&pagelist);
 	}
@@ -1499,6 +1503,10 @@ static long do_mbind(unsigned long start, unsigned long len,
 	long err;
 	long nr_failed;
 	LIST_HEAD(pagelist);
+	const struct migrate_control ctl = {
+		.mode = MIGRATE_SYNC,
+		.reason = MR_MEMPOLICY_MBIND,
+	};
 
 	if (flags & ~(unsigned long)MPOL_MF_VALID)
 		return -EINVAL;
@@ -1616,8 +1624,7 @@ static long do_mbind(unsigned long start, unsigned long len,
 	if (!err && !list_empty(&pagelist)) {
 		nr_failed |= migrate_pages(&pagelist,
 				alloc_migration_target_by_mpol, NULL,
-				(unsigned long)&mmpol, MIGRATE_SYNC,
-				MR_MEMPOLICY_MBIND, NULL);
+				(unsigned long)&mmpol, &ctl, NULL);
 	}
 
 	if (nr_failed && (flags & MPOL_MF_STRICT))
diff --git a/mm/migrate.c b/mm/migrate.c
index e4bc7122076e..549f8b57092c 100644
--- a/mm/migrate.c
+++ b/mm/migrate.c
@@ -2312,9 +2312,8 @@ static int migrate_lru_folios(struct list_head *from, new_folio_t get_new_folio,
  * @put_new_folio:	The function used to free target folios if migration
  *			fails, or NULL if no special handling is necessary.
  * @private:		Private data to be passed on to get_new_folio()
- * @mode:		The migration mode that specifies the constraints for
- *			folio migration, if any.
- * @reason:		The reason for folio migration.
+ * @ctl:		The policy for this migration: blocking discipline,
+ *			and reason.
  * @ret_succeeded:	Set to the number of folios migrated successfully if
  *			the caller passes a non-NULL pointer.
  *
@@ -2330,27 +2329,23 @@ static int migrate_lru_folios(struct list_head *from, new_folio_t get_new_folio,
  */
 int migrate_pages(struct list_head *from, new_folio_t get_new_folio,
 		free_folio_t put_new_folio, unsigned long private,
-		enum migrate_mode mode, enum migrate_reason reason, unsigned int *ret_succeeded)
+		const struct migrate_control *ctl, unsigned int *ret_succeeded)
 {
 	int rc, rc_gather;
 	LIST_HEAD(ret_folios);
 	struct migrate_pages_stats stats;
-	const struct migrate_control ctl = {
-		.mode = mode,
-		.reason = reason,
-	};
 
-	trace_mm_migrate_pages_start(ctl.mode, ctl.reason);
+	trace_mm_migrate_pages_start(ctl->mode, ctl->reason);
 
 	memset(&stats, 0, sizeof(stats));
 
 	rc_gather = migrate_hugetlbs(from, get_new_folio, put_new_folio, private,
-				     &ctl, &stats, &ret_folios);
+				     ctl, &stats, &ret_folios);
 	if (rc_gather < 0)
 		goto out;
 
 	rc = migrate_movable_ops_pages(from, get_new_folio, put_new_folio,
-				       private, &ctl, &stats,
+				       private, ctl, &stats,
 				       &ret_folios);
 	if (rc < 0) {
 		rc_gather = rc;
@@ -2359,7 +2354,7 @@ int migrate_pages(struct list_head *from, new_folio_t get_new_folio,
 	rc_gather += rc;
 
 	rc = migrate_lru_folios(from, get_new_folio, put_new_folio,
-			private, &ctl, &ret_folios, &stats);
+			private, ctl, &ret_folios, &stats);
 	if (rc < 0) {
 		rc_gather = rc;
 		goto out;
@@ -2386,8 +2381,8 @@ int migrate_pages(struct list_head *from, new_folio_t get_new_folio,
 	count_vm_events(THP_MIGRATION_SPLIT, stats.nr_thp_split);
 	trace_mm_migrate_pages(stats.nr_succeeded, stats.nr_failed_pages,
 			       stats.nr_thp_succeeded, stats.nr_thp_failed,
-			       stats.nr_thp_split, stats.nr_split, ctl.mode,
-			       ctl.reason);
+			       stats.nr_thp_split, stats.nr_split, ctl->mode,
+			       ctl->reason);
 
 	if (ret_succeeded)
 		*ret_succeeded = stats.nr_succeeded;
@@ -2454,9 +2449,13 @@ static int do_move_pages_to_node(struct list_head *pagelist, int node)
 		.gfp_mask = GFP_HIGHUSER_MOVABLE | __GFP_THISNODE,
 		.reason = MR_SYSCALL,
 	};
+	const struct migrate_control ctl = {
+		.mode = MIGRATE_SYNC,
+		.reason = MR_SYSCALL,
+	};
 
 	err = migrate_pages(pagelist, alloc_migration_target, NULL,
-		(unsigned long)&mtc, MIGRATE_SYNC, MR_SYSCALL, NULL);
+		(unsigned long)&mtc, &ctl, NULL);
 	if (err)
 		putback_movable_pages(pagelist);
 	return err;
@@ -2961,11 +2960,14 @@ int migrate_misplaced_folio(struct folio *folio, int node)
 	LIST_HEAD(migratepages);
 	struct mem_cgroup *memcg = get_mem_cgroup_from_folio(folio);
 	struct lruvec *lruvec = mem_cgroup_lruvec(memcg, pgdat);
+	const struct migrate_control ctl = {
+		.mode = MIGRATE_ASYNC,
+		.reason = MR_NUMA_MISPLACED,
+	};
 
 	list_add(&folio->lru, &migratepages);
 	nr_remaining = migrate_pages(&migratepages, alloc_misplaced_dst_folio,
-				     NULL, node, MIGRATE_ASYNC,
-				     MR_NUMA_MISPLACED, &nr_succeeded);
+				     NULL, node, &ctl, &nr_succeeded);
 	if (nr_remaining && !list_empty(&migratepages))
 		putback_movable_pages(&migratepages);
 	if (nr_succeeded) {
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 12fac9084c48..8a921f6cdc86 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -7146,6 +7146,10 @@ static int __alloc_contig_migrate_range(struct compact_control *cc,
 		.gfp_mask = cc->gfp_mask,
 		.reason = MR_CONTIG_RANGE,
 	};
+	const struct migrate_control ctl = {
+		.mode = cc->mode,
+		.reason = MR_CONTIG_RANGE,
+	};
 
 	lru_cache_disable();
 
@@ -7172,7 +7176,7 @@ static int __alloc_contig_migrate_range(struct compact_control *cc,
 		cc->nr_migratepages -= nr_reclaimed;
 
 		ret = migrate_pages(&cc->migratepages, alloc_migration_target,
-			NULL, (unsigned long)&mtc, cc->mode, MR_CONTIG_RANGE, NULL);
+			NULL, (unsigned long)&mtc, &ctl, NULL);
 
 		/*
 		 * On -ENOMEM, migrate_pages() bails out right away. It is pointless
diff --git a/mm/vmscan.c b/mm/vmscan.c
index f11491ee9ed5..7e8b04c97342 100644
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -1013,6 +1013,10 @@ static unsigned int demote_folio_list(struct list_head *demote_folios,
 		.nmask = &allowed_mask,
 		.reason = MR_DEMOTION,
 	};
+	const struct migrate_control ctl = {
+		.mode = MIGRATE_ASYNC,
+		.reason = MR_DEMOTION,
+	};
 
 	if (list_empty(demote_folios))
 		return 0;
@@ -1031,8 +1035,7 @@ static unsigned int demote_folio_list(struct list_head *demote_folios,
 
 	/* Demotion ignores all cpuset and mempolicy settings */
 	migrate_pages(demote_folios, alloc_demote_folio, NULL,
-		      (unsigned long)&mtc, MIGRATE_ASYNC, MR_DEMOTION,
-		      &nr_succeeded);
+		      (unsigned long)&mtc, &ctl, &nr_succeeded);
 
 	return nr_succeeded;
 }

-- 
2.43.0