[RFC PATCH] drm/flip: drain the flip work on cleanup

From: Yaohan Li

Date: Wed Nov 18 2026 - 21:36:34 EST


drm_flip_work_cleanup() only warns when the queued or the committed list
is not empty. Nothing cancels the worker and nothing runs the tasks
that are still queued, so the caller silently leaks whatever the tasks
hold (framebuffer references, vblank references, ...) and, if the
worker is still pending, it can run after the structure embedding the
flip work has been freed.

Cancel the worker and run the remaining tasks from
drm_flip_work_cleanup(). The work item is the only producer of the
committed list, so after cancel_work_sync() the two lists can be
spliced out and iterated without holding the lock.

The helper only drains the work items that exist when it is called, so
the callers have to make sure that no new item can be queued. Both
in-tree callers already do:

- Rockchip VOP: rockchip_drm_unbind() runs drm_atomic_helper_shutdown()
before component_unbind_all(), and vop_unbind() calls
pm_runtime_disable() before vop_destroy_crtc(). The CRTC is disabled
and the device cannot be resumed when the cleanup runs, so neither
vop_plane_atomic_update() nor vop_crtc_atomic_flush() can queue a new
item, and vop_isr() returns early because
pm_runtime_get_if_in_use() fails.

- MSM mdp4/mdp5: msm_drm_uninit() destroys the KMS, which releases the
interrupt, before drm_dev_put() runs the drmm actions. The flip
cleanup action is registered after drmm_crtc_alloc_with_planes(), so
it runs before drmm_crtc_cleanup() and after the vblank interrupt
that commits the work is gone.

Rockchip VOP called drm_flip_work_cleanup() after drm_crtc_cleanup(),
which memsets the CRTC. Its worker calls drm_crtc_vblank_put() on that
CRTC, so the drain has to happen before the CRTC is cleaned up.

Signed-off-by: Yaohan Li <shunsheng1218@xxxxxxxxx>

---
Prepared against v7.4-rc1-1969-g666539eecdf4.

Compile tested only: arm64 with aarch64-linux-gnu-gcc 11.4
and CONFIG_DRM_ROCKCHIP=m, CONFIG_DRM_MSM=m. The affected hardware was not
available, so the teardown path was not exercised and no fault or
race injection was run.

AI assistance: the analysis, the change and its review notes were
prepared with Claude (Anthropic) as a coding assistant. The author
reviewed the reasoning and takes responsibility for the content.
---
drivers/gpu/drm/drm_flip_work.c | 23 +++++++++++++++++++--
drivers/gpu/drm/rockchip/rockchip_drm_vop.c | 9 +++++++-
2 files changed, 29 insertions(+), 3 deletions(-)

diff --git a/drivers/gpu/drm/drm_flip_work.c b/drivers/gpu/drm/drm_flip_work.c
index 52c437746d48..b8ce3966fa9a 100644
--- a/drivers/gpu/drm/drm_flip_work.c
+++ b/drivers/gpu/drm/drm_flip_work.c
@@ -149,10 +149,29 @@ EXPORT_SYMBOL(drm_flip_work_init);
* drm_flip_work_cleanup - cleans up flip-work
* @work: the flip-work to cleanup
*
- * Destroy resources allocated for the flip-work
+ * Cancel the worker and run the tasks that are still queued, so that the
+ * resources they hold are released even if the work never made it to the
+ * workqueue. Must be called before the object embedding @work is freed and
+ * after the driver has stopped the code that calls drm_flip_work_queue()
+ * and drm_flip_work_commit(): only the work items that exist when this
+ * function is called are drained.
*/
void drm_flip_work_cleanup(struct drm_flip_work *work)
{
- WARN_ON(!list_empty(&work->queued) || !list_empty(&work->commited));
+ struct drm_flip_task *task, *tmp;
+ LIST_HEAD(tasks);
+ unsigned long flags;
+
+ cancel_work_sync(&work->worker);
+
+ spin_lock_irqsave(&work->lock, flags);
+ list_splice_tail_init(&work->queued, &tasks);
+ list_splice_tail_init(&work->commited, &tasks);
+ spin_unlock_irqrestore(&work->lock, flags);
+
+ list_for_each_entry_safe(task, tmp, &tasks, node) {
+ work->func(work, task->data);
+ kfree(task);
+ }
}
EXPORT_SYMBOL(drm_flip_work_cleanup);
diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_vop.c b/drivers/gpu/drm/rockchip/rockchip_drm_vop.c
index 69e72727da24..38935ef08b70 100644
--- a/drivers/gpu/drm/rockchip/rockchip_drm_vop.c
+++ b/drivers/gpu/drm/rockchip/rockchip_drm_vop.c
@@ -1990,12 +1990,19 @@ static void vop_destroy_crtc(struct vop *vop)
head)
drm_plane_cleanup(plane);

+ /*
+ * The flip work drops the vblank reference taken when the framebuffer
+ * was queued, so it has to be drained while the CRTC is still valid.
+ * The CRTC has been shut down and runtime PM disabled by the time this
+ * runs, so no new work item can be queued anymore.
+ */
+ drm_flip_work_cleanup(&vop->fb_unref_work);
+
/*
* Destroy CRTC after vop_plane_destroy() since vop_disable_plane()
* references the CRTC.
*/
drm_crtc_cleanup(crtc);
- drm_flip_work_cleanup(&vop->fb_unref_work);
}

static int vop_initial(struct vop *vop)
--
2.34.1