On Sat, Oct 25, 2025 at 02:04:04PM +0200, Thomas Hellström wrote:
> The hmm_range_fault() and the migration helpers currently need a common
> "owner" to identify pagemaps and clients with fast interconnect.
> Add a drm_pagemap utility to setup such owners by registering
> drm_pagemaps, in a registry, and for each new drm_pagemap,
> query which existing drm_pagemaps have fast interconnects with the new
> drm_pagemap.
>
> The "owner" scheme is limited in that it is static at drm_pagemap creation.
> Ideally one would want the owner to be adjusted at run-time, but that
> requires changes to hmm. If the proposed scheme becomes too limited,
> we need to revisit.
>
> Signed-off-by: Thomas Hellström <[email protected]>
> ---
> drivers/gpu/drm/drm_pagemap_util.c | 118 +++++++++++++++++++++++++++++
> include/drm/drm_pagemap_util.h | 53 +++++++++++++
> 2 files changed, 171 insertions(+)
>
> diff --git a/drivers/gpu/drm/drm_pagemap_util.c
> b/drivers/gpu/drm/drm_pagemap_util.c
> index e1a1d6bf25f4..dd573b620157 100644
> --- a/drivers/gpu/drm/drm_pagemap_util.c
> +++ b/drivers/gpu/drm/drm_pagemap_util.c
> @@ -3,6 +3,8 @@
> * Copyright © 2025 Intel Corporation
> */
>
> +#include <linux/slab.h>
> +
> #include <drm/drm_drv.h>
> #include <drm/drm_managed.h>
> #include <drm/drm_pagemap.h>
> @@ -424,3 +426,119 @@ struct drm_pagemap_shrinker
> *drm_pagemap_shrinker_create_devm(struct drm_device
> return shrinker;
> }
> EXPORT_SYMBOL(drm_pagemap_shrinker_create_devm);
> +
> +/**
> + * struct drm_pagemap_owner - Device interconnect group
> + * @kref: Reference count.
> + *
> + * A struct drm_pagemap_owner identifies a device interconnect group.
> + */
> +struct drm_pagemap_owner {
> + struct kref kref;
> +};
> +
> +static void drm_pagemap_owner_release(struct kref *kref)
> +{
> + kfree(container_of(kref, struct drm_pagemap_owner, kref));
> +}
> +
> +/**
> + * drm_pagemap_release_owner() - Stop participating in an interconnect group
> + * @peer: Pointer to the struct drm_pagemap_peer used when joining the group
> + *
> + * Stop participating in an interconnect group. This function is typically
> + * called when a pagemap is removed to indicate that it doesn't need to
> + * be taken into account.
> + */
> +void drm_pagemap_release_owner(struct drm_pagemap_peer *peer)
> +{
> + struct drm_pagemap_owner_list *owner_list = peer->list;
> +
> + if (!owner_list)
> + return;
> +
> + mutex_lock(&owner_list->lock);
> + list_del(&peer->link);
> + kref_put(&peer->owner->kref, drm_pagemap_owner_release);
> + peer->owner = NULL;
> + mutex_unlock(&owner_list->lock);
> +}
> +EXPORT_SYMBOL(drm_pagemap_release_owner);
> +
> +/**
> + * typedef interconnect_fn - Callback function to identify fast interconnects
> + * @peer1: First endpoint.
> + * @peer2: Second endpont.
> + *
> + * The function returns %true iff @peer1 and @peer2 have a fast interconnect.
> + * Note that this is symmetrical. The function has no notion of client and
> provider,
> + * which may not be sufficient in some cases. However, since the callback is
> intended
> + * to guide in providing common pagemap owners, the notion of a common owner
> to
> + * indicate fast interconnects would then have to change as well.
> + *
> + * Return: %true iff @peer1 and @peer2 have a fast interconnect. Otherwise
> @false.
> + */
> +typedef bool (*interconnect_fn)(struct drm_pagemap_peer *peer1, struct
> drm_pagemap_peer *peer2);
> +
> +/**
> + * drm_pagemap_acquire_owner() - Join an interconnect group
> + * @peer: A struct drm_pagemap_peer keeping track of the device interconnect
> + * @owner_list: Pointer to the owner_list, keeping track of all interconnects
> + * @has_interconnect: Callback function to determine whether two peers have a
> + * fast local interconnect.
> + *
> + * Repeatedly calls @has_interconnect for @peer and other peers on
> @owner_list to
> + * determine a set of peers for which @peer has a fast interconnect. That
> set will
> + * have common &struct drm_pagemap_owner, and upon successful return,
> @peer::owner
> + * will point to that struct, holding a reference, and @peer will be
> registered in
> + * @owner_list. If @peer doesn't have any fast interconnects to other
> @peers, a
> + * new unique &struct drm_pagemap_owner will be allocated for it, and that
> + * may be shared with other peers that, at a later point, are determined to
> have
> + * a fast interconnect with @peer.
> + *
> + * When @peer no longer participates in an interconnect group,
> + * drm_pagemap_release_owner() should be called to drop the reference on the
> + * struct drm_pagemap_owner.
> + *
> + * Return: %0 on success, negative error code on failure.
> + */
> +int drm_pagemap_acquire_owner(struct drm_pagemap_peer *peer,
> + struct drm_pagemap_owner_list *owner_list,
> + interconnect_fn has_interconnect)
> +{
> + struct drm_pagemap_peer *cur_peer;
> + struct drm_pagemap_owner *owner = NULL;
> + bool interconnect = false;
> +
> + mutex_lock(&owner_list->lock);
> + might_alloc(GFP_KERNEL);
> + list_for_each_entry(cur_peer, &owner_list->peers, link) {
> + if (cur_peer->owner != owner) {
> + if (owner && interconnect)
> + break;
> + owner = cur_peer->owner;
> + interconnect = true;
> + }
> + if (interconnect && !has_interconnect(peer, cur_peer))
> + interconnect = false;
> + }
> +
> + if (!interconnect) {
> + owner = kmalloc(sizeof(*owner), GFP_KERNEL);
> + if (!owner) {
> + mutex_unlock(&owner_list->lock);
> + return -ENOMEM;
> + }
> + kref_init(&owner->kref);
> + list_add_tail(&peer->link, &owner_list->peers);
> + } else {
> + kref_get(&owner->kref);
> + list_add_tail(&peer->link, &cur_peer->link);
> + }
> + peer->owner = owner;
> + peer->list = owner_list;
> + mutex_unlock(&owner_list->lock);
> +
> + return 0;
> +}
> +EXPORT_SYMBOL(drm_pagemap_acquire_owner);
> diff --git a/include/drm/drm_pagemap_util.h b/include/drm/drm_pagemap_util.h
> index 292244d429ee..1889630b8950 100644
> --- a/include/drm/drm_pagemap_util.h
> +++ b/include/drm/drm_pagemap_util.h
> @@ -1,12 +1,58 @@
> /* SPDX-License-Identifier: MIT */
> +/*
> + * Copyright © 2025 Intel Corporation
> + */
> +
Nit: The above copyright should be moved to an earlier patch.
> #ifndef _DRM_PAGEMAP_UTIL_H_
> #define _DRM_PAGEMAP_UTIL_H_
>
> +#include <linux/list.h>
> +#include <linux/mutex.h>
> +
> struct drm_device;
> struct drm_pagemap;
> struct drm_pagemap_cache;
> +struct drm_pagemap_owner;
> struct drm_pagemap_shrinker;
>
> +/**
> + * struct drm_pagemap_peer - Structure representing a fast interconnect peer
> + * @list: Pointer to a &struct drm_pagemap_owner_list used to keep track of
> peers
> + * @link: List link for @list's list of peers.
> + * @owner: Pointer to a &struct drm_pagemap_owner, common for a set of peers
> having
> + * fast interconnects.
> + * @private: Pointer private to the struct embedding this struct.
> + */
> +struct drm_pagemap_peer {
> + struct drm_pagemap_owner_list *list;
> + struct list_head link;
> + struct drm_pagemap_owner *owner;
> + void *private;
> +};
> +
> +/**
> + * struct drm_pagemap_owner_list - Keeping track of peers and owners
> + * @peer: List of peers.
> + *
> + * The owner list defines the scope where we identify peers having fast
> interconnects
> + * and a common owner. Typically a driver has a single global owner list to
> + * keep track of common owners for the driver's pagemaps.
> + */
> +struct drm_pagemap_owner_list {
> + /** @lock: Mutex protecting the @peers list. */
> + struct mutex lock;
> + /** @peers: List of peers. */
> + struct list_head peers;
> +};
> +
> +/*
> + * Convenience macro to define an owner list.
I'd perhaps mention this typially a static module instantiation.
Patch itself lgtm, and makes sense. With that:
Reviewed-by: Matthew Brost <[email protected]>
> + */
> +#define DRM_PAGEMAP_OWNER_LIST_DEFINE(_name) \
> + struct drm_pagemap_owner_list _name = { \
> + .lock = __MUTEX_INITIALIZER(_name.lock), \
> + .peers = LIST_HEAD_INIT(_name.peers) }
> +
> void drm_pagemap_shrinker_add(struct drm_pagemap *dpagemap);
>
> int drm_pagemap_cache_lock_lookup(struct drm_pagemap_cache *cache);
> @@ -22,4 +68,11 @@ struct drm_pagemap *drm_pagemap_get_from_cache(struct
> drm_pagemap_cache *cache);
> void drm_pagemap_cache_set_pagemap(struct drm_pagemap_cache *cache, struct
> drm_pagemap *dpagemap);
>
> struct drm_pagemap *drm_pagemap_get_from_cache_if_active(struct
> drm_pagemap_cache *cache);
> +
> +void drm_pagemap_release_owner(struct drm_pagemap_peer *peer);
> +
> +int drm_pagemap_acquire_owner(struct drm_pagemap_peer *peer,
> + struct drm_pagemap_owner_list *owner_list,
> + bool (*has_interconnect)(struct drm_pagemap_peer
> *peer1,
> + struct drm_pagemap_peer
> *peer2));
> #endif
> --
> 2.51.0
>
