dri-devel Archive on lore.kernel.org
 help / color / mirror / Atom feed
From: sashiko-bot@kernel.org
To: "Anandu Krishnan E" <anandu.e@oss.qualcomm.com>
Cc: dri-devel@lists.freedesktop.org
Subject: Re: [PATCH v4 3/3] misc: fastrpc: fix context leak and hang on signal-interrupted invoke
Date: Tue, 17 Nov 2026 10:05:46 +0000	[thread overview]
Message-ID: <sashiko-outbox-218568@kernel.org> (raw)
In-Reply-To: <20261117-interrupted-invoke-v4-v4-3-2320a8a7eda2@oss.qualcomm.com>

Thank you for your contribution! Sashiko AI review found 8 potential
issues to consider:
- [High] misc: fastrpc: recursive fl->lock deadlock in
  fastrpc_notify_users()
- [High] misc: fastrpc: hardirq-to-process fl->lock inversion in rpmsg
  callback
- [High] misc: fastrpc: use-after-free of ctx in
  fastrpc_rpmsg_callback()
- [High] misc: fastrpc: stale ctx->args reuse in
  fastrpc_context_restore_interrupted()
- [High] misc: fastrpc: DSP retval -ERESTARTSYS mishandled as signal in
  bail path
- [High] misc: fastrpc: premature ctx put in fastrpc_notify_users()
  before send
- [Medium] misc: fastrpc: leaked timed-out contexts and unreclaimed SSR
  contexts
- [Medium] misc: fastrpc: ctx_idr exhaustion blocks
  fastrpc_device_release()
--

commit 13c73e8b92c7260a0858f27cc1ca5b1e031ffdf3
Author: Anandu Krishnan E <anandu.e@oss.qualcomm.com>

misc: fastrpc: fix context leak and hang on signal-interrupted invoke

This commit parks signal-interrupted FastRPC invoke contexts on a per-user
fl->interrupted list so they can be resumed on retry without resending the
RPC message to the DSP, and updates teardown paths to drain parked
contexts.

> diff --git a/drivers/misc/fastrpc.c b/drivers/misc/fastrpc.c
> index c5c3679f87f6f..dd4d3c88e9b97 100644
> --- a/drivers/misc/fastrpc.c
> +++ b/drivers/misc/fastrpc.c

[ ... ]

> @@ -644,6 +661,54 @@ static void fastrpc_context_put_wq(struct work_struct *work)
>  	fastrpc_context_put(ctx);
>  }
>  
> +/* Schedules put_work at most once per ctx; racing callers may both try. */
> +static void fastrpc_context_schedule_put_work(struct fastrpc_invoke_ctx *ctx)
> +{
> +	bool do_schedule;
> +
> +	spin_lock(&ctx->fl->lock);
> +	do_schedule = !ctx->put_work_scheduled;
> +	ctx->put_work_scheduled = true;
> +	spin_unlock(&ctx->fl->lock);
> +
> +	if (do_schedule)
> +		schedule_work(&ctx->put_work);
> +}

[Severity: High]
Can calling fastrpc_context_schedule_put_work() from
fastrpc_rpmsg_callback() deadlock on fl->lock?

On Qualcomm GLINK and SMD transports, the endpoint callback
fastrpc_rpmsg_callback() runs in hardirq context, while process and
workqueue paths acquire fl->lock with plain spin_lock() and local
interrupts enabled:

fastrpc_context_free()
  spin_lock(&fl->lock)
  <hardirq>
    fastrpc_rpmsg_callback()
      fastrpc_context_schedule_put_work()
        spin_lock(&ctx->fl->lock)  <-- spins forever

> +
> +/* References held by ctx are left intact; only list membership changes. */
> +static void fastrpc_context_save_interrupted(struct fastrpc_invoke_ctx *ctx)
> +{
> +	spin_lock(&ctx->fl->lock);
> +	list_move_tail(&ctx->node, &ctx->fl->interrupted);
> +	spin_unlock(&ctx->fl->lock);
> +}
> +
> +/* Matches on handle+sc, not sc alone, to avoid resuming an unrelated call. */
> +static struct fastrpc_invoke_ctx *fastrpc_context_restore_interrupted(struct fastrpc_user *fl,
> +								      u32 handle, u32 sc)
> +{
> +	struct fastrpc_invoke_ctx *ctx = NULL, *ictx;
> +
> +	spin_lock(&fl->lock);
> +	list_for_each_entry(ictx, &fl->interrupted, node) {
> +		if (ictx->pid == current->pid && ictx->handle == handle &&
> +		    ictx->sc == sc) {
> +			/* May already be mid-teardown; don't resurrect it. */
> +			if (kref_get_unless_zero(&ictx->refcount)) {
> +				ctx = ictx;
> +				list_move_tail(&ctx->node, &fl->pending);
> +			}
> +			break;
> +		}
> +	}
> +	spin_unlock(&fl->lock);
> +
> +	if (ctx)
> +		fastrpc_context_put(ctx);
> +
> +	return ctx;
> +}

[Severity: High]
What happens if a signal without SA_RESTART interrupts an invoke (returning
-EINTR to user space) and the thread later calls the same (handle, sc)
method with different buffers?

fastrpc_context_restore_interrupted() matches only on pid, handle, and sc,
and fastrpc_internal_invoke() jumps straight to wait: without checking or
updating ctx->args.  The new input buffers are ignored, and when the
original DSP call finishes, fastrpc_put_args() copies output buffers via
copy_to_user() to the stale ctx->args[i].ptr addresses from the earlier
interrupted call, corrupting user-space stack or heap memory.  In addition,
if user space does not retry after -EINTR, the parked context and its DMA
buffers and ctx_idr slot remain pinned on fl->interrupted until the file
descriptor is closed.

[ ... ]

> @@ -1373,7 +1446,13 @@ static int fastrpc_internal_invoke(struct fastrpc_user *fl,  u32 kernel,
>  		return -EPERM;
>  	}
>  
> -	ctx = fastrpc_context_alloc(fl, kernel, sc, args);
> +	/* Resume an interrupted invoke instead of resending to the DSP. */
> +	if (!kernel)
> +		ctx = fastrpc_context_restore_interrupted(fl, handle, sc);
> +	if (ctx)
> +		goto wait;
> +
> +	ctx = fastrpc_context_alloc(fl, kernel, handle, sc, args);
>  	if (IS_ERR(ctx))
>  		return PTR_ERR(ctx);
>  
> @@ -1385,8 +1464,15 @@ static int fastrpc_internal_invoke(struct fastrpc_user *fl,  u32 kernel,
>  	dma_wmb();
>  	/* Send invoke buffer to remote dsp */
>  	err = fastrpc_invoke_send(fl->sctx, ctx, kernel, handle);
> -	if (err)
> -		goto bail;
> +	if (err) {
> +		/* Never sent, so not safe to park and resume like bail: does. */
> +		spin_lock(&fl->lock);
> +		list_del_init(&ctx->node);
> +		spin_unlock(&fl->lock);
> +		fastrpc_context_put(ctx);
> +		dev_dbg(fl->sctx->dev, "Error: Invoke Failed %d\n", err);
> +		return err;
> +	}
>  
>  	/*
>  	 * Set message context as polled if the call is for a user PD
> @@ -1395,7 +1481,16 @@ static int fastrpc_internal_invoke(struct fastrpc_user *fl,  u32 kernel,
>  	if (handle > FASTRPC_MAX_STATIC_HANDLE && fl->pd == USER_PD && fl->poll_mode)
>  		ctx->is_polled = true;
>  
> +wait:
>  	err = fastrpc_wait_for_completion(ctx, kernel);
> +	if (err == -ETIMEDOUT)
> +		dev_warn(fl->sctx->dev,
> +			 "fastrpc_invoke: TIMEOUT ctxid=0x%llx handle=0x%x nscalars=%d\n",
> +			 ctx->ctxid, handle, ctx->nscalars);
> +	else if (err == -ERESTARTSYS)
> +		dev_dbg(fl->sctx->dev,
> +			"fastrpc_invoke: INTERRUPTED ctxid=0x%llx handle=0x%x nscalars=%d\n",
> +			ctx->ctxid, handle, ctx->nscalars);
>  	if (err)
>  		goto bail;
>  
> @@ -1412,21 +1507,16 @@ static int fastrpc_internal_invoke(struct fastrpc_user *fl,  u32 kernel,
>  		goto bail;
>  
>  bail:
> -	if (err != -ERESTARTSYS && err != -ETIMEDOUT) {
> -		/* We are done with this compute context */
> -		spin_lock(&fl->lock);
> -		list_del(&ctx->node);
> -		spin_unlock(&fl->lock);
> -		fastrpc_context_put(ctx);
> -	}
> -
>  	if (err == -ERESTARTSYS) {
> +		fastrpc_context_save_interrupted(ctx);

[Severity: High]
What happens if the DSP completes an invocation with ctx->retval == -512
(-ERESTARTSYS)?

After fastrpc_wait_for_completion() and fastrpc_put_args() have already
completed, err = ctx->retval jumps to bail:, which treats -ERESTARTSYS as a
signal interruption and parks the completed context on fl->interrupted
without dropping the invoker reference.  When the syscall restarts and
reclaims ctx, a non-polled call hangs waiting on the already-consumed
ctx->work completion, while a polled call with ctx->is_work_done == true
repeatedly re-runs fastrpc_put_args() and drops map references in
ctx->fdlist again, underflowing mmap->refcount into a use-after-free:

drivers/misc/fastrpc.c:fastrpc_put_args() {
    ...
	/* Clean up fdlist which is updated by DSP */
	for (i = 0; i < FASTRPC_MAX_FDLIST; i++) {
		if (!fdlist[i])
			break;
		if (!fastrpc_map_lookup(fl, (int)fdlist[i], &mmap, false))
			fastrpc_map_put(mmap);
	}
    ...
}

> +	} else if (err == -ETIMEDOUT) {
> +		/* Leave linked: a late DSP answer or notify_users() still needs to reach it. */
> +		fastrpc_context_put(ctx);
> +	} else {
>  		spin_lock(&fl->lock);
> -		list_for_each_entry_safe(buf, b, &fl->mmaps, node) {
> -			list_del(&buf->node);
> -			list_add_tail(&buf->node, &fl->cctx->invoke_interrupted_mmaps);
> -		}
> +		list_del_init(&ctx->node);
>  		spin_unlock(&fl->lock);
> +		fastrpc_context_put(ctx);
>  	}
>  
>  	if (err)
> @@ -1728,13 +1818,28 @@ static int fastrpc_device_release(struct inode *inode, struct file *file)
>  {
>  	struct fastrpc_user *fl = (struct fastrpc_user *)file->private_data;
>  	struct fastrpc_channel_ctx *cctx = fl->cctx;
> -	unsigned long flags;
> +	struct fastrpc_invoke_ctx *ctx, *n;
> +	int release_err;
>  
> -	fastrpc_release_current_dsp_process(fl);
> +	release_err = fastrpc_release_current_dsp_process(fl);
>  
> -	spin_lock_irqsave(&cctx->lock, flags);
> -	list_del(&fl->user);
> -	spin_unlock_irqrestore(&cctx->lock, flags);
> +	/*
> +	 * Drop the invoker ref unconditionally: no retry can arrive once the
> +	 * fd is closed. Drop the worker ref only if the DSP confirmed it is
> +	 * done with the process; otherwise leave ctx linked so a real answer
> +	 * or a later SSR can still release it.
> +	 */
> +	spin_lock(&fl->lock);
> +	list_for_each_entry_safe(ctx, n, &fl->interrupted, node) {
> +		ctx->retval = -EPIPE;
> +		complete(&ctx->work);
> +		spin_unlock(&fl->lock);
> +		if (!release_err)
> +			fastrpc_context_schedule_put_work(ctx);
> +		fastrpc_context_put(ctx);
> +		spin_lock(&fl->lock);
> +	}
> +	spin_unlock(&fl->lock);

[Severity: Medium]
Does fastrpc_device_release() leak timed-out contexts that were left on
fl->pending?

When a kernel invoke times out (-ETIMEDOUT), bail: drops only the invoker
reference and leaves ctx linked on fl->pending holding its worker reference
and its reference on fl.  If the file descriptor is then closed and
fastrpc_release_current_dsp_process() succeeds, the DSP process is torn
down so no late reply will arrive, but fastrpc_device_release() only drains
fl->interrupted and never drops the worker reference on contexts in
fl->pending, leaking ctx and fl until the rpmsg channel is removed.
Similarly, if an interrupted invoke is retried after SSR sets cctx->rpdev
to NULL, fastrpc_internal_invoke() returns -EPIPE before calling
fastrpc_context_restore_interrupted(), leaving the parked context
unreclaimed until fd close.

[Severity: Medium]
Can parked contexts on fl->interrupted exhaust cctx->ctx_idr and prevent
fastrpc_release_current_dsp_process() from running?

Each parked context holds one of the 255 slots in cctx->ctx_idr until
fastrpc_context_free() runs, even after the DSP has already answered and
dropped the worker reference.  If 255 interrupted contexts accumulate
across the channel before fd close, fastrpc_release_current_dsp_process()
runs before fl->interrupted is drained and fails in fastrpc_context_alloc()
with -ENOSPC, so the DSP is never told to release the process and
fastrpc_device_release() skips scheduling put_work for any unanswered
contexts on fl->interrupted.

[ ... ]

> @@ -2835,13 +2940,16 @@ static void fastrpc_notify_users(struct fastrpc_user *user)
>  	list_for_each_entry(ctx, &user->pending, node) {
>  		ctx->retval = -EPIPE;
>  		complete(&ctx->work);
> -		/*
> -		 * fastrpc_invoke_send() took a second reference for the
> -		 * DSP response that will now never arrive since the
> -		 * channel is gone; schedule the matching put the same
> -		 * way a real response would via fastrpc_rpmsg_callback().
> -		 */
> -		schedule_work(&ctx->put_work);
> +		fastrpc_context_schedule_put_work(ctx);
> +	}
> +	/*
> +	 * Invoker ref for a parked context is released by fastrpc_user_free()
> +	 * or fastrpc_device_release(); this only drops the worker ref.
> +	 */
> +	list_for_each_entry(ctx, &user->interrupted, node) {
> +		ctx->retval = -EPIPE;
> +		complete(&ctx->work);
> +		fastrpc_context_schedule_put_work(ctx);
>  	}
>  	spin_unlock(&user->lock);
>  }

[Severity: High]
Does fastrpc_notify_users() deadlock on user->lock when any context is on
user->pending or user->interrupted?

fastrpc_notify_users() holds spin_lock(&user->lock) while calling
fastrpc_context_schedule_put_work(ctx), which immediately calls
spin_lock(&ctx->fl->lock) on the same spinlock (ctx->fl == user).

[Severity: High]
Can fastrpc_notify_users() drop a worker reference that was never taken for
a context on user->pending?

fastrpc_context_alloc() links ctx onto user->pending with refcount == 1
before fastrpc_get_args() and fastrpc_invoke_send() run, and
fastrpc_invoke_send() only keeps the second reference if rpmsg_send()
succeeds:

CPU0                              CPU1
fastrpc_internal_invoke()
  fastrpc_context_alloc()
    list_add_tail(..., &user->pending)
    kref_init(&ctx->refcount)
  fastrpc_get_args()
                                  fastrpc_rpmsg_remove()
                                    fastrpc_notify_users()
                                      fastrpc_context_schedule_put_work(ctx)
                                  fastrpc_context_put_wq()
                                    fastrpc_context_put(ctx)
                                      fastrpc_context_free(ctx)
  fastrpc_invoke_send()  <-- use-after-free

Because ctx is on user->pending before a successful rpmsg_send(),
put_work drops the invoker's sole reference and frees ctx while
fastrpc_internal_invoke() is still using it.

[ ... ]

> @@ -2932,11 +3036,11 @@ static int fastrpc_rpmsg_callback(struct rpmsg_device *rpdev, void *data,
>  	complete(&ctx->work);
>  
>  	/*
> -	 * The DMA buffer associated with the context cannot be freed in
> -	 * interrupt context so schedule it through a worker thread to
> -	 * avoid a kernel BUG.
> +	 * Can't free the DMA buffer in interrupt context; defer to a
> +	 * worker. Guarded: notify_users()/device_release() may also be
> +	 * racing to schedule this for the same ctx.
>  	 */
> -	schedule_work(&ctx->put_work);
> +	fastrpc_context_schedule_put_work(ctx);
>  
>  	return 0;
>  }

[Severity: High]
Can fastrpc_rpmsg_callback() dereference ctx and ctx->fl after they have
been freed by a concurrent drain?

fastrpc_rpmsg_callback() looks up ctx with idr_find(&cctx->ctx_idr, ctxid)
and drops cctx->lock without taking a reference on ctx, while
fastrpc_device_release() can now drop both the worker and invoker
references on an interrupted context (and fastrpc_context_free() leaves ctx
in cctx->ctx_idr while freeing its maps and DMA buffer):

CPU0                              CPU1
fastrpc_rpmsg_callback()
  spin_lock_irqsave(&cctx->lock)
  ctx = idr_find(&cctx->ctx_idr, ...)
  spin_unlock_irqrestore(&cctx->lock)
                                  fastrpc_device_release()
                                    fastrpc_context_schedule_put_work(ctx)
                                    fastrpc_context_put(ctx)
                                  fastrpc_context_put_wq()
                                    fastrpc_context_free()
                                      kfree(ctx)
                                      fastrpc_user_put(fl)
                                        kfree(fl)
  ctx->retval = rsp->retval;  <-- use-after-free
  complete(&ctx->work);
  fastrpc_context_schedule_put_work(ctx)
    spin_lock(&ctx->fl->lock);  <-- use-after-free

Even for a context on fl->pending whose put_work already ran from a
teardown path, calling complete(&ctx->work) lets the woken waiter drop the
last reference and free ctx and fl before fastrpc_rpmsg_callback() calls
fastrpc_context_schedule_put_work(ctx).

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261117-interrupted-invoke-v4-v4-0-2320a8a7eda2@oss.qualcomm.com?part=3

      reply	other threads:[~2026-11-17 10:05 UTC|newest]

Thread overview: 9+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-17  9:39 [PATCH v4 0/3] misc: fastrpc: fix context leak and hang on signal-interrupted invoke Anandu Krishnan E
2026-11-17  9:39 ` [PATCH v4 1/3] misc: fastrpc: remove dead context drain in fastrpc_user_free() Anandu Krishnan E
2026-11-17  9:52   ` sashiko-bot
2026-11-17 15:35   ` Ekansh Gupta
2026-11-17  9:39 ` [PATCH v4 2/3] misc: fastrpc: drop the DSP-response reference on channel removal Anandu Krishnan E
2026-11-17  9:55   ` sashiko-bot
2026-11-17 15:49   ` Ekansh Gupta
2026-11-17  9:39 ` [PATCH v4 3/3] misc: fastrpc: fix context leak and hang on signal-interrupted invoke Anandu Krishnan E
2026-11-17 10:05   ` sashiko-bot [this message]

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-218568@kernel.org \
    --to=sashiko-bot@kernel.org \
    --cc=anandu.e@oss.qualcomm.com \
    --cc=dri-devel@lists.freedesktop.org \
    --cc=sashiko-reviews@lists.linux.dev \
    /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 a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox