On Mon, 2025-10-27 at 18:23 -0700, Matthew Brost wrote:
> On Sat, Oct 25, 2025 at 02:04:01PM +0200, Thomas Hellström wrote:
> > Pagemaps are costly to set up and tear down, and they consume a lot
> > of system memory for the struct pages. Ideally they should be
> > created only when needed.
> >
> > Add a caching mechanism to allow doing just that: Create the
> > drm_pagemaps
> > when needed for migration. Keep them around to avoid destruction
> > and
> > re-creation latencies and destroy inactive/unused drm_pagemaps on
> > memory
> > pressure using a shrinker.
> >
> > Only add the helper functions. They will be hooked up to the xe
> > driver
> > in the upcoming patch.
> >
> > Signed-off-by: Thomas Hellström <[email protected]>
> > ---
> > drivers/gpu/drm/Makefile | 3 +-
> > drivers/gpu/drm/drm_pagemap.c | 79 +++++-
> > drivers/gpu/drm/drm_pagemap_util.c | 426
> > +++++++++++++++++++++++++++++
> > include/drm/drm_pagemap.h | 53 +++-
> > include/drm/drm_pagemap_util.h | 25 ++
> > 5 files changed, 569 insertions(+), 17 deletions(-)
> > create mode 100644 drivers/gpu/drm/drm_pagemap_util.c
> > create mode 100644 include/drm/drm_pagemap_util.h
> >
> > diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
> > index c2672f369aed..cdca68fd9f23 100644
> > --- a/drivers/gpu/drm/Makefile
> > +++ b/drivers/gpu/drm/Makefile
> > @@ -107,7 +107,8 @@ obj-$(CONFIG_DRM_GPUVM) += drm_gpuvm.o
> >
> > drm_gpusvm_helper-y := \
> > drm_gpusvm.o\
> > - drm_pagemap.o
> > + drm_pagemap.o\
> > + drm_pagemap_util.o
> > obj-$(CONFIG_DRM_GPUSVM) += drm_gpusvm_helper.o
> >
> > obj-$(CONFIG_DRM_BUDDY) += drm_buddy.o
> > diff --git a/drivers/gpu/drm/drm_pagemap.c
> > b/drivers/gpu/drm/drm_pagemap.c
> > index fb18a80d6a1c..5ca5b2b53bc1 100644
> > --- a/drivers/gpu/drm/drm_pagemap.c
> > +++ b/drivers/gpu/drm/drm_pagemap.c
> > @@ -8,6 +8,7 @@
> > #include <linux/pagemap.h>
> > #include <drm/drm_drv.h>
> > #include <drm/drm_pagemap.h>
> > +#include <drm/drm_pagemap_util.h>
> > #include <drm/drm_print.h>
> >
> > /**
> > @@ -578,7 +579,7 @@ static void drm_pagemap_release(struct kref
> > *ref)
> > * pagemap provider drm_device and its module.
> > */
> > dpagemap->dev_hold = NULL;
> > - kfree(dpagemap);
> > + drm_pagemap_shrinker_add(dpagemap);
> > llist_add(&dev_hold->link, &drm_pagemap_unhold_list);
> > schedule_work(&drm_pagemap_work);
> > /*
> > @@ -628,6 +629,58 @@ drm_pagemap_dev_hold(struct drm_pagemap
> > *dpagemap)
> > return dev_hold;
> > }
> >
> > +/**
> > + * drm_pagemap_reinit() - Reinitialize a drm_pagemap
> > + * @dpagemap: The drm_pagemap to reinitialize
> > + *
> > + * Reinitialize a drm_pagemap, for which drm_pagemap_release
> > + * has already been called. This interface is intended for the
> > + * situation where the driver caches a destroyed drm_pagemap.
> > + *
> > + * Return: 0 on success, negative error code on failure.
> > + */
> > +int drm_pagemap_reinit(struct drm_pagemap *dpagemap)
> > +{
> > + dpagemap->dev_hold = drm_pagemap_dev_hold(dpagemap);
> > + if (IS_ERR(dpagemap->dev_hold))
> > + return PTR_ERR(dpagemap->dev_hold);
> > +
> > + kref_init(&dpagemap->ref);
> > + return 0;
> > +}
> > +EXPORT_SYMBOL(drm_pagemap_reinit);
> > +
> > +/**
> > + * drm_pagemap_init() - Initialize a pre-allocated drm_pagemap
> > + * @dpagemap: The drm_pagemap to initialize.
> > + * @pagemap: The associated dev_pagemap providing the device
> > + * private pages.
> > + * @drm: The drm device. The drm_pagemap holds a reference on the
> > + * drm_device and the module owning the drm_device until
> > + * drm_pagemap_release(). This facilitates drm_pagemap exporting.
> > + * @ops: The drm_pagemap ops.
> > + *
> > + * Initialize and take an initial reference on a drm_pagemap.
> > + * After successful return, use drm_pagemap_put() to destroy.
> > + *
> > + ** Return: 0 on success, negative error code on error.
> > + */
> > +int drm_pagemap_init(struct drm_pagemap *dpagemap,
> > + struct dev_pagemap *pagemap,
> > + struct drm_device *drm,
> > + const struct drm_pagemap_ops *ops)
> > +{
> > + kref_init(&dpagemap->ref);
> > + dpagemap->ops = ops;
> > + dpagemap->pagemap = pagemap;
> > + dpagemap->drm = drm;
> > + dpagemap->cache = NULL;
> > + INIT_LIST_HEAD(&dpagemap->shrink_link);
> > +
> > + return drm_pagemap_reinit(dpagemap);
> > +}
> > +EXPORT_SYMBOL(drm_pagemap_init);
> > +
> > /**
> > * drm_pagemap_create() - Create a struct drm_pagemap.
> > * @drm: Pointer to a struct drm_device providing the device-
> > private memory.
> > @@ -645,22 +698,14 @@ drm_pagemap_create(struct drm_device *drm,
> > const struct drm_pagemap_ops *ops)
> > {
> > struct drm_pagemap *dpagemap = kzalloc(sizeof(*dpagemap),
> > GFP_KERNEL);
> > - struct drm_pagemap_dev_hold *dev_hold;
> > + int err;
> >
> > if (!dpagemap)
> > return ERR_PTR(-ENOMEM);
> >
> > - kref_init(&dpagemap->ref);
> > - dpagemap->drm = drm;
> > - dpagemap->ops = ops;
> > - dpagemap->pagemap = pagemap;
> > -
> > - dev_hold = drm_pagemap_dev_hold(dpagemap);
> > - if (IS_ERR(dev_hold)) {
> > - kfree(dpagemap);
> > - return ERR_CAST(dev_hold);
> > - }
> > - dpagemap->dev_hold = dev_hold;
> > + err = drm_pagemap_init(dpagemap, pagemap, drm, ops);
> > + if (err)
> > + return ERR_PTR(err);
> >
> > return dpagemap;
> > }
> > @@ -1023,6 +1068,14 @@ int drm_pagemap_populate_mm(struct
> > drm_pagemap *dpagemap,
> > }
> > EXPORT_SYMBOL(drm_pagemap_populate_mm);
> >
> > +void drm_pagemap_destroy(struct drm_pagemap *dpagemap, bool
> > is_atomic_or_reclaim)
> > +{
> > + if (dpagemap->ops->destroy)
> > + dpagemap->ops->destroy(dpagemap,
> > is_atomic_or_reclaim);
> > + else
> > + kfree(dpagemap);
> > +}
> > +
> > static void drm_pagemap_exit(void)
> > {
> > flush_work(&drm_pagemap_work);
> > diff --git a/drivers/gpu/drm/drm_pagemap_util.c
> > b/drivers/gpu/drm/drm_pagemap_util.c
> > new file mode 100644
> > index 000000000000..e1a1d6bf25f4
> > --- /dev/null
> > +++ b/drivers/gpu/drm/drm_pagemap_util.c
> > @@ -0,0 +1,426 @@
> > +// SPDX-License-Identifier: GPL-2.0-only OR MIT
> > +/*
> > + * Copyright © 2025 Intel Corporation
> > + */
> > +
> > +#include <drm/drm_drv.h>
> > +#include <drm/drm_managed.h>
> > +#include <drm/drm_pagemap.h>
> > +#include <drm/drm_pagemap_util.h>
> > +#include <drm/drm_print.h>
> > +
> > +/**
> > + * struct drm_pagemap_cache - Lookup structure for pagemaps
> > + *
> > + * Structure to keep track of active (refcount > 1) and inactive
> > + * (refcount == 0) pagemaps. Inactive pagemaps can be made active
> > + * again by waiting for the @queued completion (indicating that
> > the
> > + * pagemap has been put on the @shrinker's list of shrinkable
> > + * pagemaps, and then successfully removing it from @shrinker's
> > + * list. The latter may fail if the shrinker is already in the
> > + * process of freeing the pagemap. A struct drm_pagemap_cache can
> > + * hold a single struct drm_pagemap.
> > + */
> > +struct drm_pagemap_cache {
> > + /** @lookup_mutex: Mutex making the lookup process atomic
> > */
> > + struct mutex lookup_mutex;
> > + /** @lock: Lock protecting the @dpagemap pointer */
> > + spinlock_t lock;
> > + /** @shrinker: Pointer to the shrinker used for this
> > cache. Immutable. */
> > + struct drm_pagemap_shrinker *shrinker;
> > + /** @dpagemap: Non-refcounted pointer to the drm_pagemap
> > */
> > + struct drm_pagemap *dpagemap;
> > + /**
> > + * @queued: Signals when an inactive drm_pagemap has been
> > put on
> > + * @shrinker's list.
> > + */
> > + struct completion queued;
> > +};
> > +
> > +/**
> > + * struct drm_pagemap_shrinker - Shrinker to remove unused
> > pagemaps
> > + */
> > +struct drm_pagemap_shrinker {
> > + /** @drm: Pointer to the drm device. */
> > + struct drm_device *drm;
> > + /** @lock: Spinlock to protect the @dpagemaps list. */
> > + spinlock_t lock;
> > + /** @dpagemaps: List of unused dpagemaps. */
> > + struct list_head dpagemaps;
> > + /** @num_dpagemaps: Number of unused dpagemaps in
> > @dpagemaps. */
> > + atomic_t num_dpagemaps;
> > + /** @shrink: Pointer to the struct shrinker. */
> > + struct shrinker *shrink;
> > +};
> > +
> > +static bool drm_pagemap_shrinker_cancel(struct drm_pagemap
> > *dpagemap);
> > +
> > +static void drm_pagemap_cache_fini(void *arg)
> > +{
> > + struct drm_pagemap_cache *cache = arg;
> > + struct drm_pagemap *dpagemap;
> > +
> > + drm_dbg(cache->shrinker->drm, "Destroying dpagemap
> > cache.\n");
> > + spin_lock(&cache->lock);
> > + dpagemap = cache->dpagemap;
> > + if (!dpagemap) {
> > + spin_unlock(&cache->lock);
> > + goto out;
> > + }
> > +
> > + if (drm_pagemap_shrinker_cancel(dpagemap)) {
> > + cache->dpagemap = NULL;
> > + spin_unlock(&cache->lock);
> > + drm_pagemap_destroy(dpagemap, false);
> > + }
> > +
> > +out:
> > + mutex_destroy(&cache->lookup_mutex);
> > + kfree(cache);
> > +}
> > +
> > +/**
> > + * drm_pagemap_cache_create_devm() - Create a drm_pagemap_cache
> > + * @shrinker: Pointer to a struct drm_pagemap_shrinker.
> > + *
> > + * Create a device-managed drm_pagemap cache. The cache is
> > automatically
> > + * destroyed on struct device removal, at which point any
> > *inactive*
> > + * drm_pagemap's are destroyed.
> > + *
> > + * Return: Pointer to a struct drm_pagemap_cache on success. Error
> > pointer
> > + * on failure.
> > + */
> > +struct drm_pagemap_cache *drm_pagemap_cache_create_devm(struct
> > drm_pagemap_shrinker *shrinker)
> > +{
> > + struct drm_pagemap_cache *cache = kzalloc(sizeof(*cache),
> > GFP_KERNEL);
> > + int err;
> > +
> > + if (!cache)
> > + return ERR_PTR(-ENOMEM);
> > +
> > + mutex_init(&cache->lookup_mutex);
> > + spin_lock_init(&cache->lock);
> > + cache->shrinker = shrinker;
> > + init_completion(&cache->queued);
> > + err = devm_add_action_or_reset(shrinker->drm->dev,
> > drm_pagemap_cache_fini, cache);
> > + if (err)
> > + return ERR_PTR(err);
> > +
> > + return cache;
> > +}
> > +EXPORT_SYMBOL(drm_pagemap_cache_create_devm);
> > +
> > +/**
> > + * DOC: Cache lookup
> > + *
> > + * Cache lookup should be done under a locked mutex, so that a
> > + * failed drm_pagemap_get_from_cache() and a following
> > + * drm_pagemap_cache_setpagemap() are carried out as an atomic
> > + * operation WRT other lookups. Otherwise, racing lookups may
> > + * unnecessarily concurrently create pagemaps to fulfill a
> > + * failed lookup. The API provides two functions to perform this
> > lock,
> > + * drm_pagemap_lock_lookup() and drm_pagemap_unlock_lookup() and
> > they
> > + * should be used in the following way:
> > + *
> > + * .. code-block:: c
> > + *
> > + * drm_pagemap_lock_lookup(cache);
> > + * dpagemap = drm_pagemap_get_from_cache(cache);
> > + * if (dpagemap)
> > + * goto out_unlock;
> > + *
> > + * dpagemap = driver_create_new_dpagemap();
> > + * if (!IS_ERR(dpagemap))
> > + * drm_pagemap_cache_set_pagemap(cache,
> > dpagemap);
> > + *
> > + * out_unlock:
> > + * drm_pagemap_unlock_lookup(cache);
> > + */
> > +
> > +/**
> > + * drm_pagemap_cache_lock_lookup() Lock a drm_pagemap_cache for
> > lookup
> > + * @cache: The drm_pagemap_cache to lock.
> > + *
> > + * Return: %-EINTR if interrupted while blocking. %0 otherwise.
> > + */
> > +int drm_pagemap_cache_lock_lookup(struct drm_pagemap_cache *cache)
> > +{
> > + return mutex_lock_interruptible(&cache->lookup_mutex);
> > +}
> > +EXPORT_SYMBOL(drm_pagemap_cache_lock_lookup);
> > +
> > +/**
> > + * drm_pagemap_cache_unlock_lookup() Unlock a drm_pagemap_cache
> > after lookup
> > + * @cache: The drm_pagemap_cache to unlock.
> > + */
> > +void drm_pagemap_cache_unlock_lookup(struct drm_pagemap_cache
> > *cache)
> > +{
> > + mutex_unlock(&cache->lookup_mutex);
> > +}
> > +EXPORT_SYMBOL(drm_pagemap_cache_unlock_lookup);
> > +
> > +/**
> > + * drm_pagemap_get_from_cache() - Lookup of drm_pagemaps.
> > + * @cache: The cache used for lookup.
> > + *
> > + * If an active pagemap is present in the cache, it is immediately
> > returned.
> > + * If an inactive pagemap is present, it's removed from the
> > shrinker list and
> > + * an attempt is made to make it active.
> > + * If no pagemap present or the attempt to make it active failed,
> > %NULL is returned
> > + * to indicate to the caller to create a new drm_pagemap and
> > insert it into
> > + * the cache.
> > + *
> > + * Return: A reference-counted pointer to a drm_pagemap if
> > successful. An error
> > + * pointer if an error occurred, or %NULL if no drm_pagemap was
> > found and
> > + * the caller should insert a new one.
> > + */
> > +struct drm_pagemap *drm_pagemap_get_from_cache(struct
> > drm_pagemap_cache *cache)
> > +{
> > + struct drm_pagemap *dpagemap;
> > + int err;
> > +
> > + lockdep_assert_held(&cache->lookup_mutex);
> > +retry:
> > + spin_lock(&cache->lock);
> > + dpagemap = cache->dpagemap;
> > + if (drm_pagemap_get_unless_zero(dpagemap)) {
> > + spin_unlock(&cache->lock);
> > + return dpagemap;
> > + }
> > +
> > + if (!dpagemap) {
> > + spin_unlock(&cache->lock);
> > + return NULL;
> > + }
> > +
> > + if (!try_wait_for_completion(&cache->queued)) {
> > + spin_unlock(&cache->lock);
> > + err = wait_for_completion_interruptible(&cache-
> > >queued);
> > + if (err)
> > + return ERR_PTR(err);
> > + goto retry;
> > + }
> > +
> > + if (drm_pagemap_shrinker_cancel(dpagemap)) {
> > + cache->dpagemap = NULL;
> > + spin_unlock(&cache->lock);
> > + err = drm_pagemap_reinit(dpagemap);
> > + if (err) {
> > + drm_pagemap_destroy(dpagemap, false);
> > + return ERR_PTR(err);
> > + }
> > + drm_pagemap_cache_set_pagemap(cache, dpagemap);
> > + } else {
> > + cache->dpagemap = NULL;
> > + spin_unlock(&cache->lock);
> > + dpagemap = NULL;
> > + }
> > +
> > + return dpagemap;
> > +}
> > +EXPORT_SYMBOL(drm_pagemap_get_from_cache);
> > +
> > +/**
> > + * drm_pagemap_cache_set_pagemap() - Assign a drm_pagemap to a
> > drm_pagemap_cache
> > + * @cache: The cache to assign the drm_pagemap to.
> > + * @dpagemap: The drm_pagemap to assign.
> > + *
> > + * The function must be called to populate a drm_pagemap_cache
> > only
> > + * after a call to drm_pagemap_get_from_cache() returns NULL.
> > + */
> > +void drm_pagemap_cache_set_pagemap(struct drm_pagemap_cache
> > *cache, struct drm_pagemap *dpagemap)
> > +{
> > + struct drm_device *drm = dpagemap->drm;
> > +
> > + lockdep_assert_held(&cache->lookup_mutex);
> > + spin_lock(&cache->lock);
> > + dpagemap->cache = cache;
> > + swap(cache->dpagemap, dpagemap);
> > + reinit_completion(&cache->queued);
> > + spin_unlock(&cache->lock);
> > + drm_WARN_ON(drm, !!dpagemap);
> > +}
> > +EXPORT_SYMBOL(drm_pagemap_cache_set_pagemap);
> > +
> > +/**
> > + * drm_pagemap_get_from_cache_if_active() - Quick lookup of active
> > drm_pagemaps
> > + * @cache: The cache to lookup from.
> > + *
> > + * Function that should be used to lookup a drm_pagemap that is
> > already active.
> > + * (refcount > 0).
> > + *
> > + * Return: A pointer to the cache's drm_pagemap if it's active;
> > %NULL otherwise.
> > + */
> > +struct drm_pagemap *drm_pagemap_get_from_cache_if_active(struct
> > drm_pagemap_cache *cache)
> > +{
> > + struct drm_pagemap *dpagemap;
> > +
> > + spin_lock(&cache->lock);
> > + dpagemap = drm_pagemap_get_unless_zero(cache->dpagemap);
> > + spin_unlock(&cache->lock);
> > +
> > + return dpagemap;
> > +}
> > +EXPORT_SYMBOL(drm_pagemap_get_from_cache_if_active);
> > +
> > +static bool drm_pagemap_shrinker_cancel(struct drm_pagemap
> > *dpagemap)
> > +{
> > + struct drm_pagemap_cache *cache = dpagemap->cache;
> > + struct drm_pagemap_shrinker *shrinker = cache->shrinker;
> > +
> > + spin_lock(&shrinker->lock);
> > + if (list_empty(&dpagemap->shrink_link)) {
> > + spin_unlock(&shrinker->lock);
> > + return false;
> > + }
> > +
> > + list_del_init(&dpagemap->shrink_link);
> > + atomic_dec(&shrinker->num_dpagemaps);
> > + spin_unlock(&shrinker->lock);
> > + return true;
> > +}
> > +
> > +/**
> > + * drm_pagemap_shrinker_add() - Add a drm_pagemap to the shrinker
> > list or destroy
> > + * @dpagemap: The drm_pagemap.
> > + *
> > + * If @dpagemap is associated with a &struct drm_pagemap_cache AND
> > the
> > + * struct device backing the drm device is still alive, add
> > @dpagemap to
> > + * the &struct drm_pagemap_shrinker list of shrinkable
> > drm_pagemaps.
> > + *
> > + * Otherwise destroy the pagemap directly using
> > drm_pagemap_destroy().
> > + *
> > + * This is an internal function which is not intended to be
> > exposed to drivers.
> > + */
> > +void drm_pagemap_shrinker_add(struct drm_pagemap *dpagemap)
>
> Not a full review - slowly wrapping my head around the first 6
> patches
> but one quick question.
>
> This is called from drm_pagemap_put. How do we know what type of
> context
> we're in? It seems like this could be called from either process
> context
> or atomic context (e.g., via drm_pagemap_zdd_destroy through
> drm_pagemap_page_free). This code doesn’t appear to work in atomic
> contexts—if I recall correctly, drm_dev_enter can’t be called from
> atomic context. Also, we're missing irqsave on the spinlock.
>From reading up on srcu_read_lock(), which is hiding behind
drm_dev_enter(), it should be OK to call from atomic context as long as
it is also released from the same context. I indeed checked that we
could call it under a spinlock without getting any lockdep warnings.
The irqsave on the spinlock is a different thing, though. Do we know
that drm_pagemap_page_free() will be called from irq context?
/Thomas
>
> We had a worker for ZDD destroy at one point—should we revive that?
> If
> we did, I think we could safely enforce a rule that drm_pagemap
> operations must only be called from process context.
>
> Matt
>
> > +{
> > + struct drm_pagemap_cache *cache;
> > + struct drm_pagemap_shrinker *shrinker;
> > + int idx;
> > +
> > + /*
> > + * The pagemap cache and shrinker are disabled at
> > + * pci device remove time. After that, dpagemaps
> > + * are freed directly.
> > + */
> > + if (!drm_dev_enter(dpagemap->drm, &idx))
> > + goto out_no_cache;
> > +
> > + cache = dpagemap->cache;
> > + if (!cache) {
> > + drm_dev_exit(idx);
> > + goto out_no_cache;
> > + }
> > +
> > + shrinker = cache->shrinker;
> > + spin_lock(&shrinker->lock);
> > + list_add_tail(&dpagemap->shrink_link, &shrinker-
> > >dpagemaps);
> > + atomic_inc(&shrinker->num_dpagemaps);
> > + spin_unlock(&shrinker->lock);
> > + complete_all(&cache->queued);
> > + drm_dev_exit(idx);
> > + return;
> > +
> > +out_no_cache:
> > + drm_pagemap_destroy(dpagemap, true);
> > +}
> > +
> > +static unsigned long
> > +drm_pagemap_shrinker_count(struct shrinker *shrink, struct
> > shrink_control *sc)
> > +{
> > + struct drm_pagemap_shrinker *shrinker = shrink-
> > >private_data;
> > + unsigned long count = atomic_read(&shrinker-
> > >num_dpagemaps);
> > +
> > + return count ? : SHRINK_EMPTY;
> > +}
> > +
> > +static unsigned long
> > +drm_pagemap_shrinker_scan(struct shrinker *shrink, struct
> > shrink_control *sc)
> > +{
> > + struct drm_pagemap_shrinker *shrinker = shrink-
> > >private_data;
> > + struct drm_pagemap *dpagemap;
> > + struct drm_pagemap_cache *cache;
> > + unsigned long nr_freed = 0;
> > +
> > + sc->nr_scanned = 0;
> > + spin_lock(&shrinker->lock);
> > + do {
> > + dpagemap = list_first_entry_or_null(&shrinker-
> > >dpagemaps, typeof(*dpagemap),
> > + shrink_link);
> > + if (!dpagemap)
> > + break;
> > +
> > + atomic_dec(&shrinker->num_dpagemaps);
> > + list_del_init(&dpagemap->shrink_link);
> > + spin_unlock(&shrinker->lock);
> > +
> > + sc->nr_scanned++;
> > + nr_freed++;
> > +
> > + cache = dpagemap->cache;
> > + spin_lock(&cache->lock);
> > + cache->dpagemap = NULL;
> > + spin_unlock(&cache->lock);
> > +
> > + drm_dbg(dpagemap->drm, "Shrinking dpagemap %p.\n",
> > dpagemap);
> > + drm_pagemap_destroy(dpagemap, true);
> > + spin_lock(&shrinker->lock);
> > + } while (sc->nr_scanned < sc->nr_to_scan);
> > + spin_unlock(&shrinker->lock);
> > +
> > + return sc->nr_scanned ? nr_freed : SHRINK_STOP;
> > +}
> > +
> > +static void drm_pagemap_shrinker_fini(void *arg)
> > +{
> > + struct drm_pagemap_shrinker *shrinker = arg;
> > +
> > + drm_dbg(shrinker->drm, "Destroying dpagemap shrinker.\n");
> > + drm_WARN_ON(shrinker->drm, !!atomic_read(&shrinker-
> > >num_dpagemaps));
> > + shrinker_free(shrinker->shrink);
> > + kfree(shrinker);
> > +}
> > +
> > +/**
> > + * drm_pagemap_shrinker_create_devm() - Create and register a
> > pagemap shrinker
> > + * @drm: The drm device
> > + *
> > + * Create and register a pagemap shrinker that shrinks unused
> > pagemaps
> > + * and thereby reduces memory footprint.
> > + * The shrinker is drm_device managed and unregisters itself when
> > + * the drm device is removed.
> > + *
> > + * Return: %0 on success, negative error code on failure.
> > + */
> > +struct drm_pagemap_shrinker
> > *drm_pagemap_shrinker_create_devm(struct drm_device *drm)
> > +{
> > + struct drm_pagemap_shrinker *shrinker;
> > + struct shrinker *shrink;
> > + int err;
> > +
> > + shrinker = kzalloc(sizeof(*shrinker), GFP_KERNEL);
> > + if (!shrinker)
> > + return ERR_PTR(-ENOMEM);
> > +
> > + shrink = shrinker_alloc(0, "drm-drm_pagemap:%s", drm-
> > >unique);
> > + if (!shrink) {
> > + kfree(shrinker);
> > + return ERR_PTR(-ENOMEM);
> > + }
> > +
> > + spin_lock_init(&shrinker->lock);
> > + INIT_LIST_HEAD(&shrinker->dpagemaps);
> > + shrinker->drm = drm;
> > + shrinker->shrink = shrink;
> > + shrink->count_objects = drm_pagemap_shrinker_count;
> > + shrink->scan_objects = drm_pagemap_shrinker_scan;
> > + shrink->private_data = shrinker;
> > + shrinker_register(shrink);
> > +
> > + err = devm_add_action_or_reset(drm->dev,
> > drm_pagemap_shrinker_fini, shrinker);
> > + if (err)
> > + return ERR_PTR(err);
> > +
> > + return shrinker;
> > +}
> > +EXPORT_SYMBOL(drm_pagemap_shrinker_create_devm);
> > diff --git a/include/drm/drm_pagemap.h b/include/drm/drm_pagemap.h
> > index 5cfe54331ba7..4b9af5e785c6 100644
> > --- a/include/drm/drm_pagemap.h
> > +++ b/include/drm/drm_pagemap.h
> > @@ -9,6 +9,7 @@
> > #define NR_PAGES(order) (1U << (order))
> >
> > struct drm_pagemap;
> > +struct drm_pagemap_cache;
> > struct drm_pagemap_dev_hold;
> > struct drm_pagemap_zdd;
> > struct device;
> > @@ -124,6 +125,25 @@ struct drm_pagemap_ops {
> > unsigned long start, unsigned long end,
> > struct mm_struct *mm,
> > unsigned long timeslice_ms);
> > + /**
> > + * @destroy: Destroy the drm_pagemap and associated
> > resources.
> > + * @dpagemap: The drm_pagemap to destroy.
> > + * @is_atomic_or_reclaim: The function may be called from
> > + * atomic- or reclaim context.
> > + *
> > + * The implementation should take care not to attempt to
> > + * destroy resources that may already have been destroyed
> > + * using devm_ callbacks, since this function may be
> > called
> > + * after the underlying struct device has been unbound.
> > + * If the implementation defers the execution to a work
> > item
> > + * to avoid locking issues, then it must make sure the
> > work
> > + * items are flushed before module exit. If the destroy
> > call
> > + * happens after the provider's pci_remove() callback has
> > + * been executed, a module reference and drm device
> > reference is
> > + * held across the destroy callback.
> > + */
> > + void (*destroy)(struct drm_pagemap *dpagemap,
> > + bool is_atomic_or_reclaim);
> > };
> >
> > /**
> > @@ -135,6 +155,10 @@ struct drm_pagemap_ops {
> > * @pagemap: Pointer to the underlying dev_pagemap.
> > * @dev_hold: Pointer to a struct drm_pagemap_dev_hold for
> > * device referencing.
> > + * @cache: Back-pointer to the &struct drm_pagemap_cache used for
> > this
> > + * &struct drm_pagemap. May be NULL if no cache is used.
> > + * @shrink_link: Link into the shrinker's list of drm_pagemaps.
> > Only
> > + * used if also using a pagemap cache.
> > */
> > struct drm_pagemap {
> > const struct drm_pagemap_ops *ops;
> > @@ -142,6 +166,8 @@ struct drm_pagemap {
> > struct drm_device *drm;
> > struct dev_pagemap *pagemap;
> > struct drm_pagemap_dev_hold *dev_hold;
> > + struct drm_pagemap_cache *cache;
> > + struct list_head shrink_link;
> > };
> >
> > struct drm_pagemap_devmem;
> > @@ -210,6 +236,11 @@ struct drm_pagemap_devmem_ops {
> > unsigned long npages);
> > };
> >
> > +int drm_pagemap_init(struct drm_pagemap *dpagemap,
> > + struct dev_pagemap *pagemap,
> > + struct drm_device *drm,
> > + const struct drm_pagemap_ops *ops);
> > +
> > struct drm_pagemap *drm_pagemap_create(struct drm_device *drm,
> > struct dev_pagemap
> > *pagemap,
> > const struct
> > drm_pagemap_ops *ops);
> > @@ -228,9 +259,9 @@ static inline void drm_pagemap_put(struct
> > drm_pagemap *dpagemap)
> >
> > /**
> > * drm_pagemap_get() - Obtain a reference on a struct drm_pagemap
> > - * @dpagemap: Pointer to the struct drm_pagemap.
> > + * @dpagemap: Pointer to the struct drm_pagemap, or NULL.
> > *
> > - * Return: Pointer to the struct drm_pagemap.
> > + * Return: Pointer to the struct drm_pagemap, or NULL.
> > */
> > static inline struct drm_pagemap *
> > drm_pagemap_get(struct drm_pagemap *dpagemap)
> > @@ -241,6 +272,20 @@ drm_pagemap_get(struct drm_pagemap *dpagemap)
> > return dpagemap;
> > }
> >
> > +/**
> > + * drm_pagemap_get_unless_zero() - Obtain a reference on a struct
> > drm_pagemap
> > + * unless the current reference count is zero.
> > + * @dpagemap: Pointer to the drm_pagemap or NULL.
> > + *
> > + * Return: A pointer to @dpagemap if the reference count was
> > successfully
> > + * incremented. NULL if @dpagemap was NULL, or its refcount was 0.
> > + */
> > +static inline struct drm_pagemap * __must_check
> > +drm_pagemap_get_unless_zero(struct drm_pagemap *dpagemap)
> > +{
> > + return (dpagemap && kref_get_unless_zero(&dpagemap->ref))
> > ? dpagemap : NULL;
> > +}
> > +
> > /**
> > * struct drm_pagemap_devmem - Structure representing a GPU SVM
> > device memory allocation
> > *
> > @@ -284,5 +329,7 @@ int drm_pagemap_populate_mm(struct drm_pagemap
> > *dpagemap,
> > struct mm_struct *mm,
> > unsigned long timeslice_ms);
> >
> > -#endif
> > +void drm_pagemap_destroy(struct drm_pagemap *dpagemap, bool
> > is_atomic_or_reclaim);
> >
> > +int drm_pagemap_reinit(struct drm_pagemap *dpagemap);
> > +#endif
> > diff --git a/include/drm/drm_pagemap_util.h
> > b/include/drm/drm_pagemap_util.h
> > new file mode 100644
> > index 000000000000..292244d429ee
> > --- /dev/null
> > +++ b/include/drm/drm_pagemap_util.h
> > @@ -0,0 +1,25 @@
> > +/* SPDX-License-Identifier: MIT */
> > +#ifndef _DRM_PAGEMAP_UTIL_H_
> > +#define _DRM_PAGEMAP_UTIL_H_
> > +
> > +struct drm_device;
> > +struct drm_pagemap;
> > +struct drm_pagemap_cache;
> > +struct drm_pagemap_shrinker;
> > +
> > +void drm_pagemap_shrinker_add(struct drm_pagemap *dpagemap);
> > +
> > +int drm_pagemap_cache_lock_lookup(struct drm_pagemap_cache
> > *cache);
> > +
> > +void drm_pagemap_cache_unlock_lookup(struct drm_pagemap_cache
> > *cache);
> > +
> > +struct drm_pagemap_shrinker
> > *drm_pagemap_shrinker_create_devm(struct drm_device *drm);
> > +
> > +struct drm_pagemap_cache *drm_pagemap_cache_create_devm(struct
> > drm_pagemap_shrinker *shrinker);
> > +
> > +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);
> > +#endif
> > --
> > 2.51.0
> >
