mpol_set_shared_policy() installs a policy over a VMA's page-offset range, which is the only programmatic way to populate an inode's shared policy after init. Two limitations make it unusable for binding an entire backing inode from in-kernel code: - It requires a VMA, so it cannot cover unmapped offsets. (e.g. unmapped file folios faulted by pagecache) - mpol_shared_policy_init(), the only no-VMA installer, reconstructs the policy from mpol->w.user_nodemask. That field is only populated for static/relative or mount-string policies. a policy built programmatically (e.g. by mpol_bind_node()) leaves it empty and stores w.cpuset_mems_allowed instead, so _init mangles it. Add mpol_set_shared_policy_range(), which installs an already-built, fully contextualised policy verbatim over an arbitrary [start, end) page range with no VMA. Reimplement mpol_set_shared_policy() as a thin wrapper that derives the range from the VMA, so both share a single underlying path. Suggested-by: Dave Jiang Co-developed-by: Dave Jiang Signed-off-by: Dave Jiang Signed-off-by: Gregory Price Assisted-by: Claude:claude-opus-4-8 --- include/linux/mempolicy.h | 2 ++ mm/mempolicy.c | 35 +++++++++++++++++++++++++++++------ 2 files changed, 31 insertions(+), 6 deletions(-) diff --git a/include/linux/mempolicy.h b/include/linux/mempolicy.h index 715951a5b03c1..1348e9f5f2cf9 100644 --- a/include/linux/mempolicy.h +++ b/include/linux/mempolicy.h @@ -125,6 +125,8 @@ int vma_dup_policy(struct vm_area_struct *src, struct vm_area_struct *dst); void mpol_shared_policy_init(struct shared_policy *sp, struct mempolicy *mpol); int mpol_set_shared_policy(struct shared_policy *sp, struct vm_area_struct *vma, struct mempolicy *mpol); +int mpol_set_shared_policy_range(struct shared_policy *sp, pgoff_t start, + pgoff_t end, struct mempolicy *mpol); void mpol_free_shared_policy(struct shared_policy *sp); struct mempolicy *mpol_shared_policy_lookup(struct shared_policy *sp, pgoff_t idx); diff --git a/mm/mempolicy.c b/mm/mempolicy.c index 4daba81fff7c7..23c4c25097450 100644 --- a/mm/mempolicy.c +++ b/mm/mempolicy.c @@ -3424,24 +3424,47 @@ void mpol_shared_policy_init(struct shared_policy *sp, struct mempolicy *mpol) } EXPORT_SYMBOL_FOR_MODULES(mpol_shared_policy_init, "kvm"); -int mpol_set_shared_policy(struct shared_policy *sp, - struct vm_area_struct *vma, struct mempolicy *pol) +/** + * mpol_set_shared_policy_range - install @pol over [@start, @end) of @sp + * @sp: the shared policy tree + * @start: first page offset (inclusive) + * @end: last page offset (exclusive) + * @pol: a fully-built, validated policy, or NULL to clear the range + * + * Installs @pol over the given range, replacing any overlapping policy. + * @sp takes its own reference, the caller retains its reference on @pol. + * + * The policy is not reconstructed, so the policy is preserved exactly. + * + * Unlike mpol_set_shared_policy(), no VMA is required, so a range that + * is never mapped into a VMA can be covered, including the whole file. + * + * Return: 0 on success, -ENOMEM on allocation failure. + */ +int mpol_set_shared_policy_range(struct shared_policy *sp, pgoff_t start, + pgoff_t end, struct mempolicy *pol) { - const pgoff_t pgoff = vma_start_pgoff(vma); - const pgoff_t pgoff_end = vma_end_pgoff(vma); struct sp_node *new = NULL; int err; if (pol) { - new = sp_alloc(pgoff, pgoff_end, pol); + new = sp_alloc(start, end, pol); if (!new) return -ENOMEM; } - err = shared_policy_replace(sp, pgoff, pgoff_end, new); + err = shared_policy_replace(sp, start, end, new); if (err && new) sp_free(new); return err; } +EXPORT_SYMBOL_FOR_MODULES(mpol_set_shared_policy_range, "kvm"); + +int mpol_set_shared_policy(struct shared_policy *sp, + struct vm_area_struct *vma, struct mempolicy *pol) +{ + return mpol_set_shared_policy_range(sp, vma->vm_pgoff, + vma->vm_pgoff + vma_pages(vma), pol); +} EXPORT_SYMBOL_FOR_MODULES(mpol_set_shared_policy, "kvm"); /* Free a backing policy store on inode delete. */ -- 2.53.0-Meta