All of lore.kernel.org
 help / color / mirror / Atom feed
From: Yu Zhang <yuz08559@gmail.com>
To: Greg Kroah-Hartman <gregkh@linuxfoundation.org>,
	Neill Kapron <nkapron@google.com>
Cc: Aldo Ariel Panzardo <qwe.aldo@gmail.com>,
	linux-usb@vger.kernel.org, linux-kernel@vger.kernel.org,
	Yu Zhang <yuz08559@gmail.com>
Subject: [PATCH v2] usb: gadget: f_ecm: serialize notification state with a spinlock
Date: Sat, 21 Nov 2026 21:41:54 +1000	[thread overview]
Message-ID: <20261121114154.30274-1-yuz08559@gmail.com> (raw)

ecm_do_notify() guards re-entry only with an atomic_read() of
notify_count, then fills ecm->notify_req, does atomic_inc() and
usb_ep_queue().  This check-fill-inc-queue sequence is not atomic and
runs from three contexts that share no lock: ecm_notify_complete(),
ecm_open()/ecm_close() (netdev up/down via u_ether) and ecm_set_alt().

When the completion handler decrements notify_count to 0 and re-enters
ecm_do_notify(), a concurrent ecm_close()/ecm_set_alt() can observe
notify_count == 0 in the window between the atomic_dec() and the next
atomic_inc(), and queue the same ecm->notify_req a second time.  The
request is then added to the endpoint queue twice (list_add corruption),
and notify_state is updated concurrently.

struct f_ecm has carried a FIXME about this missing locking.  The sibling
f_ncm already serializes the identical state machine with a per-instance
spinlock.  Do the same in f_ecm: take ecm->lock across the is_open update
and ecm_notify() in open/close/set_alt and across the state update in
ecm_notify_complete(), dropping it only around usb_ep_queue().

Signed-off-by: Yu Zhang <yuz08559@gmail.com>
---
v2:
 - Take ecm->lock with guard()/scoped_guard() in ecm_open(), ecm_close(),
   ecm_set_alt() and ecm_notify_complete() instead of explicit
   spin_lock()/spin_unlock() pairs (Greg Kroah-Hartman).  The lock is
   still dropped around usb_ep_queue() in ecm_do_notify(), as f_ncm does,
   because the completion can run before usb_ep_queue() returns.  No
   change to what is protected.
 - Sent as a new thread.
v1: https://lore.kernel.org/all/20261026060031.60582-1-yuz08559@gmail.com/

 drivers/usb/gadget/function/f_ecm.c | 20 ++++++++++++++++----
 1 file changed, 16 insertions(+), 4 deletions(-)

diff --git a/drivers/usb/gadget/function/f_ecm.c b/drivers/usb/gadget/function/f_ecm.c
--- a/drivers/usb/gadget/function/f_ecm.c
+++ b/drivers/usb/gadget/function/f_ecm.c
@@ -59,9 +59,8 @@ struct f_ecm {
 	atomic_t			notify_count;
 	bool				is_open;
 
-	/* FIXME is_open needs some irq-ish locking
-	 * ... possibly the same as port.ioport
-	 */
+	/* protects the notification state machine */
+	spinlock_t			lock;
 };
 
 static inline struct f_ecm *func_to_ecm(struct usb_function *f)
@@ -414,7 +413,11 @@ static void ecm_do_notify(struct f_ecm *
 	event->wIndex = cpu_to_le16(ecm->ctrl_id);
 
 	atomic_inc(&ecm->notify_count);
+
+	/* ecm_notify_complete() can run before usb_ep_queue() returns */
+	spin_unlock(&ecm->lock);
 	status = usb_ep_queue(ecm->notify, req, GFP_ATOMIC);
+	spin_lock(&ecm->lock);
 	if (status < 0) {
 		atomic_dec(&ecm->notify_count);
 		DBG(cdev, "notify --> %d\n", status);
@@ -438,6 +441,8 @@ static void ecm_notify_complete(struct u
 	struct usb_composite_dev	*cdev = ecm->port.func.config->cdev;
 	struct usb_cdc_notification	*event = req->buf;
 
+	guard(spinlock)(&ecm->lock);
+
 	switch (req->status) {
 	case 0:
 		/* no fault */
@@ -588,7 +593,8 @@ static int ecm_set_alt(struct usb_functi
 		 * follow another (if the first is in flight), and instead
 		 * just guarantee that a speed notification is always sent.
 		 */
-		ecm_notify(ecm);
+		scoped_guard(spinlock, &ecm->lock)
+			ecm_notify(ecm);
 	} else
 		goto fail;
 
@@ -653,6 +659,8 @@ static void ecm_open(struct gether *geth
 
 	DBG(ecm->port.func.config->cdev, "%s\n", __func__);
 
+	guard(spinlock)(&ecm->lock);
+
 	ecm->is_open = true;
 	ecm_notify(ecm);
 }
@@ -663,6 +671,8 @@ static void ecm_close(struct gether *get
 
 	DBG(ecm->port.func.config->cdev, "%s\n", __func__);
 
+	guard(spinlock)(&ecm->lock);
+
 	ecm->is_open = false;
 	ecm_notify(ecm);
 }
@@ -942,6 +952,8 @@ static struct usb_function *ecm_alloc(st
 	if (!ecm)
 		return ERR_PTR(-ENOMEM);
 
+	spin_lock_init(&ecm->lock);
+
 	opts = container_of(fi, struct f_ecm_opts, func_inst);
 	mutex_lock(&opts->lock);
 	opts->refcnt++;

                 reply	other threads:[~2026-11-21 11:42 UTC|newest]

Thread overview: [no followups] expand[flat|nested]  mbox.gz  Atom feed

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=20261121114154.30274-1-yuz08559@gmail.com \
    --to=yuz08559@gmail.com \
    --cc=gregkh@linuxfoundation.org \
    --cc=linux-kernel@vger.kernel.org \
    --cc=linux-usb@vger.kernel.org \
    --cc=nkapron@google.com \
    --cc=qwe.aldo@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.