All of lore.kernel.org
 help / color / mirror / Atom feed
From: sashiko-bot@kernel.org
To: "Yaohan Li" <shunsheng1218@gmail.com>
Cc: dri-devel@lists.freedesktop.org
Subject: Re: [RFC PATCH] drm/flip: drain the flip work on cleanup
Date: Thu, 19 Nov 2026 02:51:37 +0000	[thread overview]
Message-ID: <sashiko-outbox-222347@kernel.org> (raw)
In-Reply-To: <20261119023604.1495603-1-shunsheng1218@gmail.com>

Thank you for your contribution! Sashiko AI review found 2 potential
issues to consider:
- [High] drm/msm: NULL deref and UAF in unref_cursor_worker() on flip
  cleanup
- [Low] drm/flip: missing Fixes: trailers on bug-fix commit
--

commit 73632c7ec76b9cf83dec08873d97bb312392eec3
Author: Yaohan Li <shunsheng1218@gmail.com>

> drm/flip: drain the flip work on cleanup
>
> 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@gmail.com>

[Severity: Low]
Since this fixes the missing drain in drm_flip_work_cleanup() and the
cleanup ordering in Rockchip VOP, should it include Fixes: tags?

  Fixes: cabaafc78935 ("drm: add flip-work helper")
  Fixes: 47a7eb459777 ("drm/rockchip: Unreference framebuffers from flip work")

> diff --git a/drivers/gpu/drm/drm_flip_work.c b/drivers/gpu/drm/drm_flip_work.c
> index 52c437746d483..b8ce3966fa9ab 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);
> +	}
>  }

[Severity: High]
Can calling work->func() here cause a NULL pointer dereference and
use-after-free in MSM mdp4 and mdp5 when an uncommitted cursor task
remains in unref_cursor_work.queued at teardown?

In msm_drm_uninit(), KMS is torn down and ddev->dev_private is cleared
before drm_dev_put() runs the drmm-registered mdp4_crtc_flip_cleanup() /
mdp5_crtc_flip_cleanup() actions:

drivers/gpu/drm/msm/msm_drv.c:msm_drm_uninit() {
    ...
	if (priv->kms)
		msm_drm_kms_uninit(dev);
    ...
	ddev->dev_private = NULL;
	drm_dev_put(ddev);
}

msm_drm_kms_uninit() flushes kms->wq (which only runs tasks already
committed by a vblank IRQ) and then calls mdp4_destroy() or
mdp5_kms_destroy(), which drops kms->vm via drm_gpuvm_put(kms->vm).

If a cursor update was queued via mdp4_crtc_cursor_set() or
mdp5_crtc_cursor_set() without a subsequent vblank interrupt to commit it,
the task stays in unref_cursor_work.queued until drm_dev_put() runs
drm_flip_work_cleanup().  That invokes unref_cursor_worker():

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c:unref_cursor_worker() {
	struct mdp5_crtc *mdp5_crtc =
		container_of(work, struct mdp5_crtc, unref_cursor_work);
	struct mdp5_kms *mdp5_kms = get_kms(&mdp5_crtc->base);
	struct msm_kms *kms = &mdp5_kms->base.base;

	msm_gem_unpin_iova(val, kms->vm);
	drm_gem_object_put(val);
}

get_kms() reads crtc->dev->dev_private (now NULL) and dereferences
priv->kms, and kms->vm has already been destroyed (along with the
devm-allocated KMS structures if an open DRM fd delayed the final
drm_dev_put() past device unbind).

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261119023604.1495603-1-shunsheng1218@gmail.com?part=1

  reply	other threads:[~2026-11-19  2:51 UTC|newest]

Thread overview: 8+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-19  2:36 [RFC PATCH] drm/flip: drain the flip work on cleanup Yaohan Li
2026-11-19  2:51 ` sashiko-bot [this message]
2026-11-19  8:31 ` [RFC PATCH v2 1/2] drm/msm: release the cursor flip work before the KMS is torn down Yaohan Li
2026-11-19  8:31   ` Yaohan Li
2026-11-19  8:31   ` [RFC PATCH v2 2/2] drm/flip: drain the flip work on cleanup Yaohan Li
2026-11-19  8:31     ` Yaohan Li
2026-11-19  8:48   ` [RFC PATCH v2 1/2] drm/msm: release the cursor flip work before the KMS is torn down sashiko-bot
2026-11-19 11:18     ` Yaohan Li

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=sashiko-outbox-222347@kernel.org \
    --to=sashiko-bot@kernel.org \
    --cc=dri-devel@lists.freedesktop.org \
    --cc=sashiko-reviews@lists.linux.dev \
    --cc=shunsheng1218@gmail.com \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.