net/sched: serialize qdisc_rtab_list against concurrent get/put
Subsystems (4)
A message that is not in the archive (sent off-list or not yet received): CAP48HfvFnArD5hDW8gCAWrp4Hz8Pbh7m3A8F6DiPtLYq45WOBg@mail.gmail.com
A message that is not in the archive (sent off-list or not yet received): CAM0EoMntb24oXpBW-pAYVX1WYTNnTU9eJLe-cvoiD-GGdW-Rkw@mail.gmail.com
A message that is not in the archive (sent off-list or not yet received): CANn89iK63bSCL3MPBQKiYEwYfioNYkvTBYVL8cavM2THQbPyhA@mail.gmail.com
A message that is not in the archive (sent off-list or not yet received): CANn89i+6K3TrAx0Jq_6Z+OtLBt6DhV6_dNjU5U6m6epucPzVVg@mail.gmail.com
A message that is not in the archive (sent off-list or not yet received): CANn89iLFBPHjjOZg5p7b=-vA++17oBLCJtGi8aJXnfJ3j67J1g@mail.gmail.com
PATCH v2 1/1 net/sched: serialize qdisc_rtab_list against concurrent get/put
qdisc_get_rtab() and qdisc_put_rtab() mutate the process-global singly linked list qdisc_rtab_list and a plain non-atomic 'int refcnt' with no lock. This was only safe because every caller historically held the RTNL mutex, which serialized all rate-table lookups, inserts and frees.
That invariant no longer holds. cls_flower sets TCF_PROTO_OPS_DOIT_UNLOCKED, so tc_new_tfilter() keeps rtnl_held == false for it and sets TCA_ACT_FLAGS_NO_RTNL. That flag propagates through tcf_exts_validate_ex() -> tcf_action_init() -> tcf_action_init_1() -> tcf_police_init(), which calls qdisc_get_rtab()/qdisc_put_rtab() with the RTNL mutex NOT held. Two RTM_NEWTFILTER requests on different CPUs, each adding a flower filter with a police action carrying the same rate, then race on qdisc_rtab_list and on the non-atomic refcnt, leading to a use-after-free / double-free of the kmalloc-2k struct qdisc_rate_table. qdisc_rtab_list is a single global (not per-netns), so the corrupted object is shared system-wide.
BUG: KASAN: slab-use-after-free in qdisc_put_rtab+0x12f/0x160 qdisc_put_rtab+0x12f/0x160 tcf_police_init+0xda9/0x1590 tcf_action_init_1+0x460/0x6b0 tcf_action_init+0x439/0xa40 tcf_exts_validate_ex+0x42d/0x550 fl_change+0xddd/0x7da0 tc_new_tfilter+0xaa7/0x2420 rtnetlink_rcv_msg+0x95e/0xe90 which belongs to the cache kmalloc-2k of size 2048
Protect qdisc_rtab_list and the refcount with a dedicated spinlock. The (sleeping, GFP_KERNEL) allocation in qdisc_get_rtab() is performed before taking the lock; if a concurrent inserter added an identical table in the meantime the freshly allocated one is freed under the lock, so no duplicate is leaked. qdisc_put_rtab() now decrements the refcount and unlinks under the same lock.
---
v2:
- Rework qdisc_get_rtab() to allocate before taking the lock and free the surplus table under the lock instead of dropping the lock to allocate and re-scanning (Eric Dumazet).
- Add Fixes: tag and Cc: stable.
- Build-tested (CONFIG_NET_SCHED=y).
v1 was sent privately to [email protected] on 2026-07-11; moving to the public list now that a fix is ready, as requested.
net/sched/sch_api.c | 24 +++++++++++++++++++----- 1 file changed, 19 insertions(+), 5 deletions(-)
net/sched/sch_api.c +19 -5
@@ -415,12 +415,13 @@ static __u8 __detect_linklayer(struct tc_ratespec *r, __u32 *rtab) }static struct qdisc_rate_table *qdisc_rtab_list; +static DEFINE_SPINLOCK (qdisc_rtab_lock);struct qdisc_rate_table *qdisc_get_rtab (struct tc_ratespec *r,struct nlattr *tab,struct netlink_ext_ack *extack) { -struct qdisc_rate_table *rtab; +struct qdisc_rate_table *rtab, *new_rtab; if (tab == NULL || r->rate == 0 || r->cell_log == 0 || r->cell_log >= 32 ||
@@ -429,15 +430,20 @@ struct qdisc_rate_table *qdisc_get_rtab(struct tc_ratespec *r,return NULL ; } + new_rtab =kmalloc_obj (*new_rtab); + +spin_lock (&qdisc_rtab_lock);for (rtab = qdisc_rtab_list; rtab; rtab = rtab->next) {if (!memcmp (&rtab->rate, r,sizeof (struct tc_ratespec )) && !memcmp (&rtab->data,nla_data (tab),TC_RTAB_SIZE )) { rtab->refcnt++; +spin_unlock (&qdisc_rtab_lock); +kfree (new_rtab);return rtab; } } - rtab =kmalloc_obj (*rtab); + rtab = new_rtab;if (rtab) { rtab->rate = *r; rtab->refcnt =1 ;
@@ -449,6 +455,7 @@ struct qdisc_rate_table *qdisc_get_rtab(struct tc_ratespec *r, }else {NL_SET_ERR_MSG (extack,"Failed to allocate new qdisc rate table" ); } +spin_unlock (&qdisc_rtab_lock);return rtab; }EXPORT_SYMBOL (qdisc_get_rtab);
@@ -457,18 +464,25 @@ void qdisc_put_rtab(struct qdisc_rate_table *tab) {struct qdisc_rate_table *rtab, **rtabp; -if (!tab || --tab->refcnt) +if (!tab)return ; +spin_lock (&qdisc_rtab_lock); +if (--tab->refcnt) { +spin_unlock (&qdisc_rtab_lock); +return ; + } +for (rtabp = &qdisc_rtab_list; (rtab = *rtabp) !=NULL ; rtabp = &rtab->next) {if (rtab == tab) { *rtabp = rtab->next; -kfree (rtab); -return ; +break ; } } +spin_unlock (&qdisc_rtab_lock); +kfree (tab); }EXPORT_SYMBOL (qdisc_put_rtab);
Signature · 1 line
2.43.0
Quoted 36 lines · Aldo Ariel Panzardo
qdisc_get_rtab()andqdisc_put_rtab()mutate the process-global singly linked listqdisc_rtab_listand a plain non-atomic 'int refcnt' with no lock. This was only safe because every caller historically held the RTNL mutex, which serialized all rate-table lookups, inserts and frees.That invariant no longer holds.
cls_flowersetsTCF_PROTO_OPS_DOIT_UNLOCKED, sotc_new_tfilter()keepsrtnl_held== false for it and setsTCA_ACT_FLAGS_NO_RTNL. That flag propagates throughtcf_exts_validate_ex()->tcf_action_init()->tcf_action_init_1()->tcf_police_init(), which calls qdisc_get_rtab()/qdisc_put_rtab() with the RTNL mutex NOT held. TwoRTM_NEWTFILTERrequests on different CPUs, each adding a flower filter with a police action carrying the same rate, then race onqdisc_rtab_listand on the non-atomic refcnt, leading to a use-after-free / double-free of the kmalloc-2k structqdisc_rate_table.qdisc_rtab_listis a single global (not per-netns), so the corrupted object is shared system-wide.BUG: KASAN: slab-use-after-free in qdisc_put_rtab+0x12f/0x160 qdisc_put_rtab+0x12f/0x160 tcf_police_init+0xda9/0x1590 tcf_action_init_1+0x460/0x6b0 tcf_action_init+0x439/0xa40 tcf_exts_validate_ex+0x42d/0x550 fl_change+0xddd/0x7da0 tc_new_tfilter+0xaa7/0x2420 rtnetlink_rcv_msg+0x95e/0xe90 which belongs to the cache kmalloc-2k of size 2048Protect
qdisc_rtab_listand the refcount with a dedicated spinlock. The (sleeping,GFP_KERNEL) allocation inqdisc_get_rtab()is performed before taking the lock; if a concurrent inserter added an identical table in the meantime the freshly allocated one is freed under the lock, so no duplicate is leaked.qdisc_put_rtab()now decrements the refcount and unlinks under the same lock.
Quoted 3 lines
Fixes 470502de5bdb ("net: sched: unlock rules update API")Suggested-by Eric Dumazet <[email protected]>Signed-off-by Aldo Ariel Panzardo <[email protected]>
The fix looks reasonable to me. I also tested the poc
So:
cheers,
jamal
Quoted 96 lines
---
v2:
- Reworkqdisc_get_rtab()to allocate before taking the lock and free the surplus table under the lock instead of dropping the lock to allocate and re-scanning (Eric Dumazet).
- Add Fixes: tag and Cc: stable.
- Build-tested (CONFIG_NET_SCHED=y).v1 was sent privately to [email protected] on 2026-07-11; moving to the public list now that a fix is ready, as requested.
net/sched/sch_api.c | 24 +++++++++++++++++++----- 1 file changed, 19 insertions(+), 5 deletions(-)net/sched/sch_api.c +19
-6@@ -415,12 +415,13 @@ static __u8 __detect_linklayer(struct tc_ratespec *r, __u32 *rtab) }static struct qdisc_rate_table *qdisc_rtab_list; +static DEFINE_SPINLOCK (qdisc_rtab_lock);struct qdisc_rate_table *qdisc_get_rtab (struct tc_ratespec *r,struct nlattr *tab,struct netlink_ext_ack *extack) { -struct qdisc_rate_table *rtab; +struct qdisc_rate_table *rtab, *new_rtab; if (tab == NULL || r->rate == 0 || r->cell_log == 0 || r->cell_log >= 32 ||@@ -429,15 +430,20 @@ struct qdisc_rate_table *qdisc_get_rtab(struct tc_ratespec *r,return NULL ; } + new_rtab =kmalloc_obj (*new_rtab); + +spin_lock (&qdisc_rtab_lock);for (rtab = qdisc_rtab_list; rtab; rtab = rtab->next) {if (!memcmp (&rtab->rate, r,sizeof (struct tc_ratespec )) && !memcmp (&rtab->data,nla_data (tab),TC_RTAB_SIZE )) { rtab->refcnt++; +spin_unlock (&qdisc_rtab_lock); +kfree (new_rtab);return rtab; } } - rtab =kmalloc_obj (*rtab); + rtab = new_rtab;if (rtab) { rtab->rate = *r; rtab->refcnt =1 ;@@ -449,6 +455,7 @@ struct qdisc_rate_table *qdisc_get_rtab(struct tc_ratespec *r, }else {NL_SET_ERR_MSG (extack,"Failed to allocate new qdisc rate table" ); } +spin_unlock (&qdisc_rtab_lock);return rtab; }EXPORT_SYMBOL (qdisc_get_rtab);@@ -457,18 +464,25 @@ void qdisc_put_rtab(struct qdisc_rate_table *tab) {struct qdisc_rate_table *rtab, **rtabp; -if (!tab || --tab->refcnt) +if (!tab)return ; +spin_lock (&qdisc_rtab_lock); +if (--tab->refcnt) { +spin_unlock (&qdisc_rtab_lock); +return ; + } +for (rtabp = &qdisc_rtab_list; (rtab = *rtabp) !=NULL ; rtabp = &rtab->next) {if (rtab == tab) { *rtabp = rtab->next; -kfree (rtab); -return ; +break ; } } +spin_unlock (&qdisc_rtab_lock); +kfree (tab); }EXPORT_SYMBOL (qdisc_put_rtab); --2.43.0
Eric Dumazet
Reviewed-byQuoted 38 lines · Jamal Hadi Salim
Quoted 36 lines · Aldo Ariel Panzardo
qdisc_get_rtab()andqdisc_put_rtab()mutate the process-global singly linked listqdisc_rtab_listand a plain non-atomic 'int refcnt' with no lock. This was only safe because every caller historically held the RTNL mutex, which serialized all rate-table lookups, inserts and frees.That invariant no longer holds.
cls_flowersetsTCF_PROTO_OPS_DOIT_UNLOCKED, sotc_new_tfilter()keepsrtnl_held== false for it and setsTCA_ACT_FLAGS_NO_RTNL. That flag propagates throughtcf_exts_validate_ex()->tcf_action_init()->tcf_action_init_1()->tcf_police_init(), which calls qdisc_get_rtab()/qdisc_put_rtab() with the RTNL mutex NOT held. TwoRTM_NEWTFILTERrequests on different CPUs, each adding a flower filter with a police action carrying the same rate, then race onqdisc_rtab_listand on the non-atomic refcnt, leading to a use-after-free / double-free of the kmalloc-2k structqdisc_rate_table.qdisc_rtab_listis a single global (not per-netns), so the corrupted object is shared system-wide.BUG: KASAN: slab-use-after-free in qdisc_put_rtab+0x12f/0x160 qdisc_put_rtab+0x12f/0x160 tcf_police_init+0xda9/0x1590 tcf_action_init_1+0x460/0x6b0 tcf_action_init+0x439/0xa40 tcf_exts_validate_ex+0x42d/0x550 fl_change+0xddd/0x7da0 tc_new_tfilter+0xaa7/0x2420 rtnetlink_rcv_msg+0x95e/0xe90 which belongs to the cache kmalloc-2k of size 2048Protect
qdisc_rtab_listand the refcount with a dedicated spinlock. The (sleeping,GFP_KERNEL) allocation inqdisc_get_rtab()is performed before taking the lock; if a concurrent inserter added an identical table in the meantime the freshly allocated one is freed under the lock, so no duplicate is leaked.qdisc_put_rtab()now decrements the refcount and unlinks under the same lock.
Quoted 7 lines
Quoted 3 lines
Fixes 470502de5bdb ("net: sched: unlock rules update API")Suggested-by Eric Dumazet <[email protected]>Signed-off-by Aldo Ariel Panzardo <[email protected]>The fix looks reasonable to me. I also tested the poc
So:Acked-by Jamal Hadi Salim <[email protected]>
Same here, thanks!
This patch was applied to netdev/net.git (main) by Jakub Kicinski <[email protected]>:
Hello:
This patch was applied to netdev/net.git (main)
by Jakub Kicinski <[email protected]>:
Quoted 17 lines · On Wed, 15 Jul 2026 08:41:14 -0300 you wrote:
qdisc_get_rtab()andqdisc_put_rtab()mutate the process-global singly linked listqdisc_rtab_listand a plain non-atomic 'int refcnt' with no lock. This was only safe because every caller historically held the RTNL mutex, which serialized all rate-table lookups, inserts and frees.That invariant no longer holds.
cls_flowersetsTCF_PROTO_OPS_DOIT_UNLOCKED, sotc_new_tfilter()keepsrtnl_held== false for it and setsTCA_ACT_FLAGS_NO_RTNL. That flag propagates throughtcf_exts_validate_ex()->tcf_action_init()->tcf_action_init_1()->tcf_police_init(), which calls qdisc_get_rtab()/qdisc_put_rtab() with the RTNL mutex NOT held. TwoRTM_NEWTFILTERrequests on different CPUs, each adding a flower filter with a police action carrying the same rate, then race onqdisc_rtab_listand on the non-atomic refcnt, leading to a use-after-free / double-free of the kmalloc-2k structqdisc_rate_table.qdisc_rtab_listis a single global (not per-netns), so the corrupted object is shared system-wide.
Quoted 1 line
[...]
Here is the summary with links:
- [net,v2] net/sched: serialize qdisc_rtab_list against concurrent get/put
https://git.kernel.org/netdev/net/c/f43ee0c0730d
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html