The Linux Kernel Mailing List
 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 a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox