Introduce a common DRM user fence helper providing the kref-managed, MM-borrowing dma-fence-callback-to-workqueue pattern used by drivers that must access userspace memory from a kthread context when a GPU fence signals.
XE uses this pattern (xe_sync.c) to write a fence completion value to a userspace VA. AMDGPU will use the same pattern to signal a per-queue eventfd from a user-queue EOP fence callback. The helper provides: - struct drm_user_fence: embeddable base structure - struct drm_user_fence_ops: worker/destroy callbacks - drm_user_fence_init(): initialize and grab the process MM - drm_user_fence_get/put(): reference counting - drm_user_fence_add_callback(): attach to a dma-fence The worker callback receives a bool indicating whether the process MM was successfully obtained, allowing drivers to handle the unavailable-MM case (log, skip the userspace write, etc.) without duplicating the mmget/kthread_use_mm/mmput boilerplate. Suggested-by: Christian König <[email protected]> Cc: Alex Deucher <[email protected]> Cc: Maarten Lankhorst <[email protected]> Cc: Maxime Ripard <[email protected]> Cc: Thomas Zimmermann <[email protected]> Cc: David Airlie <[email protected]> Cc: Simona Vetter <[email protected]> Cc: Sumit Semwal <[email protected]> Cc: Matthew Brost <[email protected]> Cc: Thomas Hellström <[email protected]> Cc: [email protected] Cc: [email protected] Cc: [email protected] Cc: [email protected] Cc: [email protected] Cc: [email protected] Signed-off-by: Srinivasan Shanmugam <[email protected]> --- drivers/gpu/drm/Makefile | 1 + drivers/gpu/drm/drm_user_fence.c | 130 +++++++++++++++++++++++++++++++ include/drm/drm_user_fence.h | 68 ++++++++++++++++ 3 files changed, 199 insertions(+) create mode 100644 drivers/gpu/drm/drm_user_fence.c create mode 100644 include/drm/drm_user_fence.h diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile index e97faabcd783..52de1f474535 100644 --- a/drivers/gpu/drm/Makefile +++ b/drivers/gpu/drm/Makefile @@ -69,6 +69,7 @@ drm-y := \ drm_syncobj.o \ drm_sysfs.o \ drm_trace_points.o \ + drm_user_fence.o \ drm_vblank.o \ drm_vblank_work.o \ drm_vma_manager.o \ diff --git a/drivers/gpu/drm/drm_user_fence.c b/drivers/gpu/drm/drm_user_fence.c new file mode 100644 index 000000000000..bd76e3d03120 --- /dev/null +++ b/drivers/gpu/drm/drm_user_fence.c @@ -0,0 +1,130 @@ +// SPDX-License-Identifier: MIT +/* + * Copyright © 2024 The Linux Foundation + * + * Common DRM user fence helper. + * + * When a GPU dma-fence signals, drivers often need to write a value to a + * userspace VA or notify userspace via an eventfd. Both operations require + * a valid process MM, which is not available in IRQ context. + * + * This helper queues a work item on fence signal. The work item borrows the + * process MM via kthread_use_mm() and calls ops->worker(), which the driver + * implements to perform the actual userspace access. + */ + +#include <linux/kthread.h> +#include <linux/sched/mm.h> +#include <linux/workqueue.h> + +#include <drm/drm_user_fence.h> + +static void drm_user_fence_destroy(struct kref *kref) +{ + struct drm_user_fence *ufence = + container_of(kref, struct drm_user_fence, refcount); + + mmdrop(ufence->mm); + ufence->ops->destroy(ufence); +} + +/** + * drm_user_fence_get - Acquire a reference to a user fence + * @ufence: user fence + */ +void drm_user_fence_get(struct drm_user_fence *ufence) +{ + kref_get(&ufence->refcount); +} +EXPORT_SYMBOL_GPL(drm_user_fence_get); + +/** + * drm_user_fence_put - Release a reference to a user fence + * @ufence: user fence + */ +void drm_user_fence_put(struct drm_user_fence *ufence) +{ + kref_put(&ufence->refcount, drm_user_fence_destroy); +} +EXPORT_SYMBOL_GPL(drm_user_fence_put); + +static void drm_user_fence_work(struct work_struct *w) +{ + struct drm_user_fence *ufence = + container_of(w, struct drm_user_fence, work); + bool mm_ok = false; + + if (mmget_not_zero(ufence->mm)) { + kthread_use_mm(ufence->mm); + mm_ok = true; + } + + ufence->ops->worker(ufence, mm_ok); + + if (mm_ok) { + kthread_unuse_mm(ufence->mm); + mmput(ufence->mm); + } + + drm_user_fence_put(ufence); +} + +static void drm_user_fence_cb(struct dma_fence *fence, struct dma_fence_cb *cb) +{ + struct drm_user_fence *ufence = + container_of(cb, struct drm_user_fence, cb); + + INIT_WORK(&ufence->work, drm_user_fence_work); + queue_work(ufence->wq, &ufence->work); +} + +/** + * drm_user_fence_init - Initialize a user fence + * @ufence: user fence to initialize + * @wq: workqueue to run the worker on (must be ordered if sequencing matters) + * @ops: driver operations + * + * Must be called from process context. Grabs a reference to current->mm. + */ +void drm_user_fence_init(struct drm_user_fence *ufence, + struct workqueue_struct *wq, + const struct drm_user_fence_ops *ops) +{ + kref_init(&ufence->refcount); + ufence->mm = current->mm; + mmgrab(ufence->mm); + ufence->wq = wq; + ufence->ops = ops; +} +EXPORT_SYMBOL_GPL(drm_user_fence_init); + +/** + * drm_user_fence_add_callback - Attach a user fence to a dma-fence + * @ufence: user fence + * @fence: dma-fence to watch; caller retains ownership of this reference + * + * When @fence signals, a work item is queued that calls ops->worker() with + * the process MM active. If @fence has already signaled the work item is + * queued immediately. + * + * Return: 0 on success, negative errno on error. + */ +int drm_user_fence_add_callback(struct drm_user_fence *ufence, + struct dma_fence *fence) +{ + int err; + + drm_user_fence_get(ufence); + err = dma_fence_add_callback(fence, &ufence->cb, drm_user_fence_cb); + if (err == -ENOENT) { + /* fence already signaled — queue work immediately */ + INIT_WORK(&ufence->work, drm_user_fence_work); + queue_work(ufence->wq, &ufence->work); + err = 0; + } else if (err) { + drm_user_fence_put(ufence); + } + + return err; +} +EXPORT_SYMBOL_GPL(drm_user_fence_add_callback); diff --git a/include/drm/drm_user_fence.h b/include/drm/drm_user_fence.h new file mode 100644 index 000000000000..de8e3f47be18 --- /dev/null +++ b/include/drm/drm_user_fence.h @@ -0,0 +1,68 @@ +/* SPDX-License-Identifier: MIT */ +/* + * Copyright © 2024 The Linux Foundation + */ + +#ifndef __DRM_USER_FENCE_H__ +#define __DRM_USER_FENCE_H__ + +#include <linux/dma-fence.h> +#include <linux/kref.h> +#include <linux/workqueue.h> + +struct drm_user_fence; + +/** + * struct drm_user_fence_ops - driver callbacks for a DRM user fence + */ +struct drm_user_fence_ops { + /** + * @worker: Called from workqueue context. + * + * If @mm_ok is true, kthread_use_mm() is active and userspace memory + * (copy_to_user, eventfd_signal, etc.) may be accessed safely. + * If @mm_ok is false, the process MM was already gone; the driver + * should log a warning and skip the userspace write. + * + * wake_up() or other post-signal housekeeping should also happen here. + */ + void (*worker)(struct drm_user_fence *ufence, bool mm_ok); + + /** + * @destroy: Called when the last reference is dropped. + * Free the containing structure here. + */ + void (*destroy)(struct drm_user_fence *ufence); +}; + +/** + * struct drm_user_fence - embeddable DRM user fence + * + * Drivers embed this in their own structure and implement + * &drm_user_fence_ops. Call drm_user_fence_init() at creation and + * drm_user_fence_add_callback() to arm on a dma-fence. + */ +struct drm_user_fence { + /** @refcount: Reference count. */ + struct kref refcount; + /** @mm: Process MM grabbed at init time. */ + struct mm_struct *mm; + /** @work: Work item queued when the dma-fence signals. */ + struct work_struct work; + /** @cb: dma-fence callback. */ + struct dma_fence_cb cb; + /** @wq: Workqueue to run @work on. */ + struct workqueue_struct *wq; + /** @ops: Driver operations. */ + const struct drm_user_fence_ops *ops; +}; + +void drm_user_fence_init(struct drm_user_fence *ufence, + struct workqueue_struct *wq, + const struct drm_user_fence_ops *ops); +void drm_user_fence_get(struct drm_user_fence *ufence); +void drm_user_fence_put(struct drm_user_fence *ufence); +int drm_user_fence_add_callback(struct drm_user_fence *ufence, + struct dma_fence *fence); + +#endif /* __DRM_USER_FENCE_H__ */ -- 2.34.1
