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. v2: - Improve documentation of DRM_PAGEMAP_OWNER_LIST_DEFINE(). (Matt Brost) Signed-off-by: Thomas Hellström <[email protected]> Reviewed-by: Matthew Brost <[email protected]> --- drivers/gpu/drm/drm_pagemap_util.c | 118 +++++++++++++++++++++++++++++ include/drm/drm_pagemap_util.h | 50 ++++++++++++ 2 files changed, 168 insertions(+) diff --git a/drivers/gpu/drm/drm_pagemap_util.c b/drivers/gpu/drm/drm_pagemap_util.c index 84a7a4807bef..413183b2e871 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> @@ -448,3 +450,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 924244d5b899..19169b42b891 100644 --- a/include/drm/drm_pagemap_util.h +++ b/include/drm/drm_pagemap_util.h @@ -6,11 +6,55 @@ #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. + * Typically the owner list statically declared + * driver-wide. + */ +#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); @@ -39,4 +83,10 @@ static inline void drm_pagemap_shrinker_might_lock(struct drm_pagemap *dpagemap) #endif /* CONFIG_PROVE_LOCKING */ +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.1
