All of lore.kernel.org
 help / color / mirror / Atom feed
From: Kyle Zeng <kylebot@openai.com>
To: netdev-bot+sashiko@kernel.org
Cc: netdev@vger.kernel.org, jhs@mojatatu.com, jiri@resnulli.us,
	kuba@kernel.org, linux-kernel@vger.kernel.org
Subject: Re: [PATCH net v2] net/sched: serialize autonomous timers with qdisc resets
Date: Fri, 20 Nov 2026 13:57:21 -0800	[thread overview]
Message-ID: <awDCQf7I1sG9LTLa@com-75606> (raw)
In-Reply-To: <179465832501.2199510.6314071993812416961@kernel.org>

On Sat, Nov 14, 2026 at 12:12:05PM +0000, netdev-bot+sashiko@kernel.org wrote:
> Thank you for your contribution! Sashiko AI review found 3 potential
> issue(s) to consider.
> 
> Critical: 0 · High: 2 · Medium: 1 · Low: 0
> 
> If you believe none of the issues are legitimate, please reply to each
> issue of Medium severity or higher and explain why the AI is wrong.
> If any of them are legitimate and you plan to respin, please let patchwork
> know by including "pw-bot: cr" as a separate line at the end of your reply
> (one such reply per series is enough).
> 
> - [High] The fix does not cover HTB offload mode.
> - [High] net/sched: sfq_perturbation() runs on detached child before
>   qdisc_reset()
> - [Medium] The new qdisc_lock_root_sleeping() relies on a stated
>   invariant: the sleeping root only changes in dev_graft_qdisc(), under...
> 
> --
> 
> net/sched: serialize autonomous timers with qdisc resets
> 
> This adds qdisc_lock_root_sleeping(). The helper takes the sleeping
> root's lock under RCU and retries if the root changed while it waited.
> The SFQ, RED, PIE, FQ-PIE and DualPI2 timers now use it.
> 
> Default qdisc attach and shutdown now go through dev_graft_qdisc().
> __qdisc_destroy() holds the tree lock across the final qdisc_reset().
> The final resets of TAPRIO children move to taprio_destroy().
> 
> > diff --git a/include/net/sch_generic.h b/include/net/sch_generic.h
> > index 1acaadb3e2cf0..e234256e6ae81 100644
> > --- a/include/net/sch_generic.h
> > +++ b/include/net/sch_generic.h
> > @@ -608,6 +608,26 @@ static inline spinlock_t *qdisc_root_sleeping_lock(const struct Qdisc *qdisc)
> >  	return qdisc_lock(root);
> >  }
> >  
> > +/* The caller must hold rcu_read_lock().  dev_graft_qdisc() changes the
> > + * sleeping root under the old root's lock, so retry if it changed while
> > + * we were waiting for that lock.
> > + */
> > +static inline spinlock_t *qdisc_lock_root_sleeping(const struct Qdisc *qdisc)
> > +{
> > +	struct Qdisc *root;
> > +	/* Lock of the sleeping root observed under RCU. */
> > +	spinlock_t *lock;
> > +
> > +	for (;;) {
> > +		root = qdisc_root_sleeping(qdisc);
> > +		lock = qdisc_lock(root);
> > +		spin_lock(lock);
> > +		if (root == qdisc_root_sleeping(qdisc))
> > +			return lock;
> > +		spin_unlock(lock);
> > +	}
> > +}
> 
> [Severity: Medium]
> Is the invariant in this comment complete? qdisc_root_sleeping() reads
> qdisc->dev_queue->qdisc_sleeping. qdisc->dev_queue can also change, and
> there it changes without any root lock held:
> 
> net/sched/sch_htb.c:htb_offload_move_qdisc() {
>     ...
> 	if (!(cl_old->leaf.q->flags & TCQ_F_BUILTIN))
> 		cl_old->leaf.q->dev_queue = queue_new;
> 	cl_old->leaf.offload_queue = queue_new;
>     ...
> }
> 
> When destroying is true, both dev_graft_qdisc() calls around this store
> are skipped.
> 
> One possible sequence:
> 
> 1. An HTB offload root is replaced by mq. At the same time, an unlocked
>    filter request holds a reference on the old HTB through
>    __tcf_qdisc_find() -> qdisc_refcount_inc_nz().
> 
> 2. mq_attach() grafts each txq to its own mq child. queue_old and
>    queue_new now have different sleeping roots, O and N.
> 
> 3. The delayed final put calls htb_destroy() ->
>    htb_destroy_class_offload(..., destroying=true). The driver reports
>    a moved classid. htb_offload_move_qdisc() then switches the moved
>    leaf L from queue_old to queue_new with no lock held.
> 
> 4. htb_destroy_class(moved_cl) -> qdisc_put(L) -> __qdisc_destroy(L) ->
>    sch_tree_lock(L) now takes N's lock and calls qdisc_reset(L).
> 
> 5. Suppose L is an SFQ whose sfq_perturbation() validated O before the
>    switch and still holds O's lock. sfq_rehash() and sfq_reset() would
>    then run at the same time on L.
> 
> Can this still reach the final-reset-vs-timer corruption this patch is
> meant to close?
> 
> The two plain reads of qdisc->dev_queue in qdisc_lock_root_sleeping()
> also race with the plain store in htb_offload_move_qdisc().
> 
> The window looks narrow, since the timer has to hold O's lock from
> before the dev_queue switch until __qdisc_destroy() takes N's lock. It
> looks reachable on PREEMPT_RT or with vCPU preemption.
> 
> [ ... ]
> 
> > diff --git a/net/sched/sch_sfq.c b/net/sched/sch_sfq.c
> > index 8bbcfc9e85d94..2bd3fc65053ac 100644
> > --- a/net/sched/sch_sfq.c
> > +++ b/net/sched/sch_sfq.c
> > @@ -611,8 +611,7 @@ static void sfq_perturbation(struct timer_list *t)
> >  
> >  	get_random_bytes(&nkey, sizeof(nkey));
> >  	rcu_read_lock();
> > -	root_lock = qdisc_lock(qdisc_root_sleeping(sch));
> > -	spin_lock(root_lock);
> > +	root_lock = qdisc_lock_root_sleeping(sch);
> >  	q->perturbation = nkey;
> >  	if (!q->filter_list && q->tail)
> >  		sfq_rehash(sch);
> 
> [Severity: High]
> Does this close the window for a detached tree that still holds
> packets?
> 
> Since 47e8dbb6e763, a root qdisc_graft() calls
> dev_deactivate(dev, false). The old tree therefore keeps its packets
> until this qdisc_reset() runs. Several things happen before we get
> here:
> 
> - dev_graft_qdisc() has switched every txq's sleeping root.
> - qdisc_graft() has done rcu_assign_pointer(dev->qdisc, new ? :
>   &noop_qdisc).
> - __qdisc_destroy() itself has done qdisc_hash_del().
> - gen_kill_estimator() has run, and it can block in
>   timer_shutdown_sync().
> 
> During that window, an SFQ child C of the old root still has q->tail
> set and an armed perturb timer. One possible sequence, for example
> deleting a root prio 1: that has an sfq child with perturb set:
> 
> CPU1 (RTNL)                          CPU2 (perturb timer)
> qdisc_graft(dev, NULL, ...)
>   dev_graft_qdisc() per txq
>   dev->qdisc = &noop_qdisc
>   notify_and_destroy()
>     qdisc_put(old)
>       __qdisc_destroy(old)
>         qdisc_hash_del(old)
>         gen_kill_estimator()
>                                      sfq_perturbation(C)
>                                        qdisc_lock_root_sleeping(C)
>                                          locks new root, passes
>                                        sfq_rehash(C)
>                                          qdisc_tree_reduce_backlog(C)
>         sch_tree_lock(old)
>         qdisc_reset(old)
> 
> The timer validates the new sleeping root. That is the same lock
> sch_tree_lock(old) takes later, so the rehash and the reset are
> serialized.
> 
> However, the tree that C belongs to is no longer reachable.
> qdisc_tree_reduce_backlog() looks up TC_H_MAJ(C->parent) with
> qdisc_lookup_rcu() on the live device. The old root is gone from
> dev->qdisc and from the hash, so the lookup returns NULL and hits
> WARN_ON_ONCE(parentid != TC_H_ROOT).
> 
> If some live qdisc happens to match that major handle, the dropped
> count and drop_len are subtracted from its q.qlen and
> qstats.backlog instead. Those packets never belonged to it, so its
> q.qlen can underflow.
> 
> As far as I can tell, qdisc_tree_reduce_backlog() no longer returns
> early when n and len are both 0. A rehash that drops nothing
> therefore still walks the parents.
> 
> This needs only CAP_NET_ADMIN in a network namespace owned by an
> unprivileged user namespace. With panic_on_warn, the WARN becomes a
> panic.
> 
> The timer behaviour predates this patch. But the commit message says
> the validated root remains current until the timer unlocks, and that
> the final reset is now serialized with autonomous timers. Holding a
> current root's lock does not mean sch is still part of that root's
> tree.
> 
> Should the old tree be emptied before it is unpublished, as
> dev_deactivate() did before 47e8dbb6e763? Or should the autonomous
> timers be stopped, or skip their work on a detached qdisc, before
> the hierarchy is unlinked?
> 
> [Severity: High]
> Does this cover HTB offload mode?
> 
> In offload mode, htb_init() sets TCQ_F_MQROOT on the HTB qdisc, so
> sch_tree_lock(htb) takes qdisc_lock(htb) itself. Each offloaded leaf is
> attached directly to its own txq. qdisc_root_sleeping(leaf) is
> therefore that txq's qdisc_sleeping, never the HTB:
> 
> net/sched/sch_htb.c:htb_graft() {
>     ...
> 	if (q->offload) {
> 		/* One ref for cl->leaf.q, the other for dev_queue->qdisc. */
> 		qdisc_refcount_inc(new);
> 		old_q = htb_graft_helper(dev_queue, new);
> 	}
> 
> 	*old = qdisc_replace(sch, new, &cl->leaf.q);
>     ...
> }
> 
> htb_graft_helper() -> dev_graft_qdisc() sets dev_queue->qdisc_sleeping
> to new. qdisc_replace() -> sch_tree_lock(sch) then takes the HTB's own
> lock. Under that lock, qdisc_purge_queue(old) -> qdisc_reset(old) ->
> sfq_reset() runs.
> 
> With an HTB offload capable device (for example mlx5) and an SFQ leaf
> that has perturb set, can the following happen?
> 
> CPU1 (RTNL)                          CPU2 (perturb timer)
> htb_graft()
>   htb_graft_helper(dev_queue, new)
>                                      sfq_perturbation(old)
>                                        qdisc_lock_root_sleeping(old)
>                                          locks qdisc_lock(new), passes
>   qdisc_replace()
>     sch_tree_lock(htb)
>     qdisc_purge_queue(old)
>       sfq_reset(old)                   sfq_rehash(old)
> 
> The reset holds the HTB's lock and the timer holds new's lock, so
> nothing serializes them. Would this corrupt the slot lists, q->tail,
> q->ht and the per-slot skb lists that the commit message describes?
> 
> htb_delete() in offload mode seems to follow the same pattern. First,
> htb_destroy_class_offload(..., false, ...) calls
> htb_graft_helper(dev_queue, NULL). The txq's sleeping root becomes
> noop_qdisc, or new_q after htb_parent_to_leaf_offload() for a last
> child. Then:
> 
> net/sched/sch_htb.c:htb_delete() {
>     ...
> 	sch_tree_lock(sch);
> 
> 	if (!cl->level)
> 		qdisc_purge_queue(cl->leaf.q);
>     ...
> }
> 
> Meanwhile the leaf's timer takes noop_qdisc's lock or new_q's lock.
> 
> This race existed before this patch. However, the commit message says
> the patch closes timer races "with queue resets during graft". Should
> qdisc_replace() and qdisc_purge_queue() under an MQROOT parent also be
> serialized against the child's sleeping-root lock?
> 
> -- 
> Sashiko AI review · https://netdev-ai.bots.linux.dev/sashiko/#/patchset/20261110044450.51921-1-kylebot%40openai.com

Thanks. I agree with these findings.

The patch fixes stale-root lock acquisition and serializes the final
reset, but it does not establish stable queue ownership for offloaded
HTB, serialize every offloaded-leaf purge, or prevent detached SFQ
from accounting against the live hierarchy.

These are distinct, pre-existing issues. I would prefer to address
them in separate patches and keep v2 focused.

Kyle

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

Thread overview: 4+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-10  4:44 [PATCH net v2] net/sched: serialize autonomous timers with qdisc resets Kyle Zeng
2026-11-14 12:12 ` netdev-bot+sashiko
2026-11-20 21:57   ` Kyle Zeng [this message]
2026-11-20 22:28     ` Jakub Kicinski

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=awDCQf7I1sG9LTLa@com-75606 \
    --to=kylebot@openai.com \
    --cc=jhs@mojatatu.com \
    --cc=jiri@resnulli.us \
    --cc=kuba@kernel.org \
    --cc=linux-kernel@vger.kernel.org \
    --cc=netdev-bot+sashiko@kernel.org \
    --cc=netdev@vger.kernel.org \
    /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.