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 <[email protected]>

> 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 <[email protected]>

[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/[email protected]?part=1

Reply via email to