Skip to contentSkip to conversation

net/sched: Restrict conditions for adding duplicating netems to qdisc tree

PATCH Superseded William Liu 2 participants 3 messages Jun 24, 2025 – Jun 25, 2025

Subsystems (5)

v3 of 5 Superseded Latest is v5 →

lore
Share & tools
lore
#0 lore raw

PATCH v3 1/2 net/sched: Restrict conditions for adding duplicating netems to qdisc tree

netem_enqueue's duplication prevention logic breaks when a netem resides in a qdisc tree with other netems - this can lead to a soft lockup and OOM loop in netem_dequeue as seen in [1]. Since we do not want to add bits to sk_buff for tracking duplication metadata for this one specific case, we have to ensure that a duplicating netem cannot exist in a tree with other netems. Technically, this check is only required on the ancestral path, but filters and actions can change a packet's path in the qdisc tree and require us to apply the restriction over the tree.

[1] https://lore.kernel.org/netdev/8DuRWwfqjoRDLDmBMlIfbrsZg9Gx50DHJc1ilxsEBNe2D6NMoigR_eIRIG0LOjMc3r10nUUZtArXx4oZBIdUfZQrwjcQhdinnMis_0G7VEk=@willsroot.io/

Fixes 0afb51e72855 ("[PKT_SCHED]: netem: reinsert for duplication")

---
v2 -> v3:
- Clarify reasoning for approach in changelog
- Removed has_duplication
v1 -> v2: https://lore.kernel.org/all/[email protected]/
- Renamed only_duplicating to duplicates and invert logic for clarity

---
 net/sched/sch_netem.c | 40 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
net/sched/sch_netem.c +40 -0
index fdd79d3ccd8c..eafc316ae319 100644
@@ -973,6 +973,41 @@ static int parse_attr(struct nlattr *tb[], int maxtype, struct nlattr *nla,
 	return 0;
 }
 
+static const struct Qdisc_class_ops netem_class_ops;
+
+static int check_netem_in_tree(struct Qdisc *sch, bool duplicates,
+			       struct netlink_ext_ack *extack)
+{
+	struct Qdisc *root, *q;
+	unsigned int i;
+
+	root = qdisc_root_sleeping(sch);
+
+	if (sch != root && root->ops->cl_ops == &netem_class_ops) {
+		if (duplicates ||
+		    ((struct netem_sched_data *)qdisc_priv(root))->duplicate)
+			goto err;
+	}
+
+	if (!qdisc_dev(root))
+		return 0;
+
+	hash_for_each(qdisc_dev(root)->qdisc_hash, i, q, hash) {
+		if (sch != q && q->ops->cl_ops == &netem_class_ops) {
+			if (duplicates ||
+			    ((struct netem_sched_data *)qdisc_priv(q))->duplicate)
+				goto err;
+		}
+	}
+
+	return 0;
+
+err:
+	NL_SET_ERR_MSG(extack,
+		       "netem: cannot mix duplicating netems with other netems in tree");
+	return -EINVAL;
+}
+
 /* Parse netlink message to set options */
 static int netem_change(struct Qdisc *sch, struct nlattr *opt,
 			struct netlink_ext_ack *extack)
@@ -1031,6 +1066,11 @@ static int netem_change(struct Qdisc *sch, struct nlattr *opt,
 	q->gap = qopt->gap;
 	q->counter = 0;
 	q->loss = qopt->loss;
+
+	ret = check_netem_in_tree(sch, qopt->duplicate, extack);
+	if (ret)
+		goto unlock;
+
 	q->duplicate = qopt->duplicate;
 
 	/* for compatibility with earlier versions.
Signature · 1 line
2.43.0
#1 lore raw

PATCH v3 2/2 selftests/tc-testing: Add tests for restrictions on netem duplication

Ensure that a duplicating netem cannot exist in a tree with other netems in both qdisc addition and change. This is meant to prevent the soft lockup and OOM loop scenario discussed in [1]. Also adjust a HFSC's re-entrancy test case with netem for this new restriction - KASAN still triggers upon its failure.

[1] https://lore.kernel.org/netdev/8DuRWwfqjoRDLDmBMlIfbrsZg9Gx50DHJc1ilxsEBNe2D6NMoigR_eIRIG0LOjMc3r10nUUZtArXx4oZBIdUfZQrwjcQhdinnMis_0G7VEk=@willsroot.io/

---
v1 -> v2: https://lore.kernel.org/all/[email protected]/
- Fixed existing test case for new restrictions
- Add test cases
- Use dummy instead of lo

---
 .../tc-testing/tc-tests/infra/qdiscs.json     |  5 +-
 .../tc-testing/tc-tests/qdiscs/netem.json     | 81 +++++++++++++++++++
 2 files changed, 83 insertions(+), 3 deletions(-)
tools/testing/selftests/tc-testing/tc-tests/infra/qdiscs.json +2 -3
index 9aa44d8176d9..9acc88297484 100644
@@ -478,7 +478,6 @@
             "$TC qdisc add dev $DUMMY parent 1:1 handle 2:0 netem duplicate 100%",
             "$TC filter add dev $DUMMY parent 1:0 protocol ip prio 1 u32 match ip dst 10.10.10.1/32 flowid 1:1",
             "$TC class add dev $DUMMY parent 1:0 classid 1:2 hfsc ls m2 10Mbit",
-            "$TC qdisc add dev $DUMMY parent 1:2 handle 3:0 netem duplicate 100%",
             "$TC filter add dev $DUMMY parent 1:0 protocol ip prio 2 u32 match ip dst 10.10.10.2/32 flowid 1:2",
             "ping -c 1 10.10.10.1 -I$DUMMY > /dev/null || true",
             "$TC filter del dev $DUMMY parent 1:0 protocol ip prio 1",
@@ -491,8 +490,8 @@
             {
                 "kind": "hfsc",
                 "handle": "1:",
-                "bytes": 392,
-                "packets": 4
+                "bytes": 294,
+                "packets": 3
             }
         ],
         "matchCount": "1",
tools/testing/selftests/tc-testing/tc-tests/qdiscs/netem.json +81 -0

86 lines not on this page · raw message

Signature · 1 line
2.43.0
maintainer
#2 lore raw
In reply to William Liu

Please, just wait maybe a day or two next time if you get feedback before sending an updated version.

Quoted 7 lines · William Liu

netem_enqueue's duplication prevention logic breaks when a netem resides in a qdisc tree with other netems - this can lead to a soft lockup and OOM loop in netem_dequeue as seen in [1]. Since we do not want to add bits to sk_buff for tracking duplication metadata for this one specific case, we have to ensure that a duplicating netem cannot exist in a tree with other netems.

I think what is useful is to describe the discussions we had, off top of my head:
1) you had the skb bits initially - to which i pointed out that it is politically incorrect solution to add more metadata bits to the skb. I posted some url, include that url from lwn
2) you then added skb cb state, to which i pointed that it can be overwritten defeating the purpose.
3) we then went to using a similar approach as mirred loop-avoidance and found out that it wont work for netem dequeu (and i cant remember what else) with stopping the loop
4) is this solution which makes it illegal to have more than one netem in a hierarchy; i.e we are identifying that as an "illegal" hierarchy.

cheers,
jamal

Quoted 83 lines

Technically, this check is only required on the ancestral path, but filters and actions can change a packet's path in the qdisc tree and require us to apply the restriction over the tree.

[1] https://lore.kernel.org/netdev/8DuRWwfqjoRDLDmBMlIfbrsZg9Gx50DHJc1ilxsEBNe2D6NMoigR_eIRIG0LOjMc3r10nUUZtArXx4oZBIdUfZQrwjcQhdinnMis_0G7VEk=@willsroot.io/

Fixes 0afb51e72855 ("[PKT_SCHED]: netem: reinsert for duplication")

---
v2 -> v3:
- Clarify reasoning for approach in changelog
- Removed has_duplication
v1 -> v2: https://lore.kernel.org/all/[email protected]/
- Renamed only_duplicating to duplicates and invert logic for clarity

---
 net/sched/sch_netem.c | 40 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
net/sched/sch_netem.c +40 -1
index fdd79d3ccd8c..eafc316ae319 100644
@@ -973,6 +973,41 @@ static int parse_attr(struct nlattr *tb[], int maxtype, struct nlattr *nla,
        return 0;
 }
 
+static const struct Qdisc_class_ops netem_class_ops;
+
+static int check_netem_in_tree(struct Qdisc *sch, bool duplicates,
+                              struct netlink_ext_ack *extack)
+{
+       struct Qdisc *root, *q;
+       unsigned int i;
+
+       root = qdisc_root_sleeping(sch);
+
+       if (sch != root && root->ops->cl_ops == &netem_class_ops) {
+               if (duplicates ||
+                   ((struct netem_sched_data *)qdisc_priv(root))->duplicate)
+                       goto err;
+       }
+
+       if (!qdisc_dev(root))
+               return 0;
+
+       hash_for_each(qdisc_dev(root)->qdisc_hash, i, q, hash) {
+               if (sch != q && q->ops->cl_ops == &netem_class_ops) {
+                       if (duplicates ||
+                           ((struct netem_sched_data *)qdisc_priv(q))->duplicate)
+                               goto err;
+               }
+       }
+
+       return 0;
+
+err:
+       NL_SET_ERR_MSG(extack,
+                      "netem: cannot mix duplicating netems with other netems in tree");
+       return -EINVAL;
+}
+
 /* Parse netlink message to set options */
 static int netem_change(struct Qdisc *sch, struct nlattr *opt,
                        struct netlink_ext_ack *extack)
@@ -1031,6 +1066,11 @@ static int netem_change(struct Qdisc *sch, struct nlattr *opt,
        q->gap = qopt->gap;
        q->counter = 0;
        q->loss = qopt->loss;
+
+       ret = check_netem_in_tree(sch, qopt->duplicate, extack);
+       if (ret)
+               goto unlock;
+
        q->duplicate = qopt->duplicate;
 
        /* for compatibility with earlier versions.
--

2.43.0