Linux USB
 help / color / mirror / Atom feed
From: sashiko-bot@kernel.org
To: "Yaohan Li" <shunsheng1218@gmail.com>
Cc: linux-usb@vger.kernel.org
Subject: Re: [RFC PATCH v2] thunderbolt: cancel the queued control requests on teardown
Date: Thu, 19 Nov 2026 11:43:52 +0000	[thread overview]
Message-ID: <sashiko-outbox-223054@kernel.org> (raw)
In-Reply-To: <20261119111907.3616041-1-shunsheng1218@gmail.com>

Thank you for your contribution! Sashiko AI review found 4 potential
issues to consider:
- [Medium] thunderbolt: use-after-free race in tb_ctl_sync_exit() and
  tb_ctl_submit_exit()
- [Medium] thunderbolt: timeout race in tb_cfg_request_sync() bypasses
  sync_users drain
- [Medium] thunderbolt: unhandled -ENOTCONN in tb_cfg_read() and
  tb_cfg_write() hits WARN
- [Medium] thunderbolt: spurious dev_WARN and unlocked queue check in
  tb_ctl_stop()
--

commit 7ad987d4a0cdf2650a891259a5534997151f16c9
Author: Yaohan Li <shunsheng1218@gmail.com>

thunderbolt: cancel the queued control requests on teardown

This commit adds tb_ctl_cancel_requests() and request tracking counters to
cancel queued control requests and wait for active submitters and
synchronous users before freeing the control channel on teardown.

> diff --git a/drivers/thunderbolt/ctl.c b/drivers/thunderbolt/ctl.c
> index 965988b18608f..5ff0e04b8265c 100644
> --- a/drivers/thunderbolt/ctl.c
> +++ b/drivers/thunderbolt/ctl.c

[ ... ]

> @@ -528,12 +534,73 @@ static void tb_cfg_request_work(struct work_struct *work)
>  	tb_cfg_request_dequeue(req);
>  }
>  
> +/*
> + * Admission for everything that uses the channel.  tb_ctl_stop() clears
> + * @running under @request_queue_lock, so taking the same lock here is what
> + * makes the waits below complete: once the channel has been stopped no new
> + * user can appear.
> + *
> + * @submitting covers a request from the moment it is admitted until it has
> + * been handed to the TX ring.  Such a request is already queued, so the
> + * teardown cancels it, but it still dereferences @ctl in tb_ctl_tx() and the
> + * rings must not be stopped under it.
> + *
> + * @sync_users covers the longer window of a synchronous request, which keeps
> + * using @ctl after the send has completed: it waits, possibly times out and
> + * then cancels the request.
> + */
> +static int tb_ctl_submit_enter(struct tb_ctl *ctl)
> +{
> +	int ret = 0;
> +
> +	mutex_lock(&ctl->request_queue_lock);
> +	if (ctl->running)
> +		ctl->submitting++;
> +	else
> +		ret = -ENOTCONN;
> +	mutex_unlock(&ctl->request_queue_lock);
> +
> +	return ret;
> +}
> +
> +static void tb_ctl_submit_exit(struct tb_ctl *ctl)
> +{
> +	mutex_lock(&ctl->request_queue_lock);
> +	ctl->submitting--;
> +	wake_up_all(&ctl->idle_wait);
> +	mutex_unlock(&ctl->request_queue_lock);
> +}
> +
> +static int tb_ctl_sync_enter(struct tb_ctl *ctl)
> +{
> +	int ret = 0;
> +
> +	mutex_lock(&ctl->request_queue_lock);
> +	if (ctl->running)
> +		ctl->sync_users++;
> +	else
> +		ret = -ENOTCONN;
> +	mutex_unlock(&ctl->request_queue_lock);
> +
> +	return ret;
> +}
> +
> +static void tb_ctl_sync_exit(struct tb_ctl *ctl)
> +{
> +	mutex_lock(&ctl->request_queue_lock);
> +	ctl->sync_users--;
> +	wake_up_all(&ctl->idle_wait);
> +	mutex_unlock(&ctl->request_queue_lock);
> +}

[Severity: Medium]
Can tb_ctl_sync_exit() and tb_ctl_submit_exit() touch ctl after it has
been freed?

wait_event() in tb_ctl_cancel_requests() (and tb_ctl_stop()) tests
!READ_ONCE(ctl->sync_users) without taking ctl->request_queue_lock, and
neither tb_ctl_cancel_requests() nor tb_ctl_free() acquires
ctl->request_queue_lock afterwards:

CPU0                                  CPU1
tb_ctl_sync_exit(ctl)
  mutex_lock(&ctl->request_queue_lock)
  ctl->sync_users--; // becomes 0
                                      tb_ctl_cancel_requests(ctl)
                                        wait_event(..., !ctl->sync_users)
                                      ...
                                      tb_ctl_free(ctl)
                                        kfree(ctl)
  wake_up_all(&ctl->idle_wait)
  mutex_unlock(&ctl->request_queue_lock)  <-- use-after-free

Acquiring and releasing ctl->request_queue_lock after wait_event() in
tb_ctl_stop() and tb_ctl_cancel_requests() would ensure the exiting thread
has finished unlocking before teardown proceeds.

[ ... ]

> @@ -621,18 +742,50 @@ struct tb_cfg_result tb_cfg_request_sync(struct tb_ctl *ctl,
>  	DECLARE_COMPLETION_ONSTACK(done);
>  	int ret;
>  
> -	ret = tb_cfg_request(ctl, req, tb_cfg_request_complete, &done);
> +	/*
> +	 * A user that times out goes on to call tb_cfg_request_cancel(), which
> +	 * dereferences @ctl.  Register so that the channel is not freed under
> +	 * it.
> +	 */
> +	ret = tb_ctl_sync_enter(ctl);
>  	if (ret) {
>  		res.err = ret;
>  		return res;
>  	}
>  
> +	/*
> +	 * A synchronous request is completed by its callback, so the same
> +	 * function serves as the cancel hook: a teardown that cancels the
> +	 * request then wakes the waiter instead of leaving it to its timeout
> +	 * with the control channel already gone.
> +	 */
> +	req->cancel = tb_cfg_request_complete;
> +
> +	ret = tb_cfg_request(ctl, req, tb_cfg_request_complete, &done);
> +	if (ret) {
> +		res.err = ret;
> +		goto out;
> +	}
> +
>  	if (!wait_for_completion_timeout(&done, timeout))
>  		tb_cfg_request_cancel(req, -ETIMEDOUT);
>  
>  	flush_work(&req->work);
>  
> -	return req->result;
> +	/*
> +	 * A teardown can cancel the request on another thread and run the
> +	 * hook above while this one is already returning.  Taking the same
> +	 * lock waits for that invocation, and clearing the hook keeps it away
> +	 * from @done once this function returns.
> +	 */
> +	mutex_lock(&req->cancel_lock);
> +	res = req->result;
> +	req->cancel = NULL;
> +	mutex_unlock(&req->cancel_lock);
> +out:
> +	tb_ctl_sync_exit(ctl);
> +
> +	return res;
>  }

[Severity: Medium]
Can a timeout racing with teardown let callers of tb_cfg_request_sync()
dereference ctl after ctl->sync_users has already dropped to zero?

CPU0                                  CPU1
tb_cfg_read()
  tb_cfg_read_raw()
    tb_cfg_request_sync(ctl, ...)
      wait_for_completion_timeout()
                                      tb_ctl_stop(ctl)
                                        ctl->running = false
      tb_cfg_request_cancel(..., -ETIMEDOUT)
        tb_cfg_request_set_error(..., -ETIMEDOUT)
                                      tb_ctl_cancel_requests(ctl)
                                        tb_cfg_request_finish_cancel(..., -ENOTCONN)
      tb_ctl_sync_exit(ctl)
        ctl->sync_users--; // 0
                                        wait_event(..., !ctl->sync_users)
                                      ...
                                      tb_ctl_free(ctl)
                                        kfree(ctl)
    usleep_range(10, 100)
    tb_cfg_request_sync(ctl, ...)  <-- use-after-free

Because tb_cfg_request_set_error() keeps the first error written,
req->result.err stays -ETIMEDOUT even though ctl->running is already
false.  Once tb_ctl_sync_exit() drops ctl->sync_users to 0,
tb_ctl_cancel_requests() finishes while tb_cfg_read_raw() (or
tb_cfg_write_raw() / icm_request()) sleeps in its retry loop and then
dereferences ctl again in tb_cfg_request_sync() and tb_ctl_warn().

> @@ -753,15 +910,73 @@ void tb_ctl_stop(struct tb_ctl *ctl)
>  	ctl->running = false;
>  	mutex_unlock(&ctl->request_queue_lock);
>  
> +	/*
> +	 * A request that passed the admission check is between the queue and
> +	 * the TX ring and still hands its packet to the ring, so wait for it
> +	 * before the rings are stopped.
> +	 */
> +	wait_event(ctl->idle_wait, !READ_ONCE(ctl->submitting));
> +
>  	tb_ring_stop(ctl->rx);
>  	tb_ring_stop(ctl->tx);
>  
>  	if (!list_empty(&ctl->request_queue))
>  		tb_ctl_WARN(ctl, "dangling request in request_queue\n");
> -	INIT_LIST_HEAD(&ctl->request_queue);
>  	tb_ctl_dbg(ctl, "control channel stopped\n");
>  }

[Severity: Medium]
Does tb_ctl_stop() now trigger a dev_WARN backtrace whenever a request is
left in ctl->request_queue for tb_ctl_cancel_requests() to cancel?

tb_domain_add() and tb_domain_remove() call tb_ctl_stop() before
tb_ctl_cancel_requests(), so any request still queued at teardown hits
tb_ctl_WARN() here before tb_ctl_cancel_requests() can run.  In addition,
list_empty(&ctl->request_queue) is checked without holding
ctl->request_queue_lock while completion work or a timeout can still be
dequeuing requests in tb_cfg_request_dequeue().

> +void tb_ctl_cancel_requests(struct tb_ctl *ctl)
> +{
> +	struct tb_cfg_request *req, *n;
> +	LIST_HEAD(requests);
> +
> +	mutex_lock(&ctl->request_queue_lock);
> +	list_for_each_entry_safe(req, n, &ctl->request_queue, list) {
> +		/*
> +		 * Take a reference and drop the one held by the queue while
> +		 * the request is still protected by the lock.  The requests
> +		 * are canceled outside of it and their completion work may
> +		 * run in the meantime: without the extra reference it could
> +		 * drop the last one and free the request under us.
> +		 */
> +		tb_cfg_request_get(req);
> +		set_bit(TB_CFG_REQUEST_CANCELED, &req->flags);
> +		clear_bit(TB_CFG_REQUEST_ACTIVE, &req->flags);
> +		list_del_init(&req->list);
> +		list_add_tail(&req->list, &requests);
> +		tb_cfg_request_put(req);
> +	}
> +	mutex_unlock(&ctl->request_queue_lock);
> +
> +	list_for_each_entry_safe(req, n, &requests, list) {
> +		cancel_work_sync(&req->work);
> +		list_del_init(&req->list);
> +		tb_cfg_request_finish_cancel(req, -ENOTCONN);
> +		tb_cfg_request_put(req);
> +	}

[Severity: Medium]
Does canceling or rejecting a synchronous config read or write with
-ENOTCONN trigger a WARN() in tb_cfg_read() and tb_cfg_write()?

When a tb_cfg_read() or tb_cfg_write() call running outside tb->lock (such
as tb_xdp_handle_request() -> tb_port_read()) is canceled here or rejected
by tb_ctl_sync_enter() after tb_ctl_stop(), tb_cfg_read_raw() and
tb_cfg_write_raw() return res.err = -ENOTCONN, which falls into the
default branch in tb_cfg_read() and tb_cfg_write():

drivers/thunderbolt/ctl.c:tb_cfg_read() {
    ...
	switch (res.err) {
	case 0:
		return 0;

	case 1:
		tb_cfg_print_error(ctl, route, &res);
		return -EIO;

	case -ETIMEDOUT:
		tb_ctl_warn(ctl, "%llx: timeout reading config space %u from %#x\n",
			    route, space, offset);
		break;

	default:
		WARN(1, "tb_cfg_read: %d\n", res.err);
		break;
	}
    ...
}

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

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

Thread overview: 4+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-19  7:55 [RFC PATCH] thunderbolt: cancel the queued control requests on teardown Yaohan Li
2026-11-19  8:12 ` sashiko-bot
2026-11-19 11:19 ` [RFC PATCH v2] " Yaohan Li
2026-11-19 11:43   ` 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-223054@kernel.org \
    --to=sashiko-bot@kernel.org \
    --cc=linux-usb@vger.kernel.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 a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox