sch_cake: Permit use of connmarks as tin classifiers

Add flag 'FWMARK' to enable use of firewall connmarks as tin selector.
The connmark (skbuff->mark) needs to be in the range 1->tin_cnt ie.
for diffserv3 the mark needs to be 1->3.

Background

Typically CAKE uses DSCP as the basis for tin selection.  DSCP values
are relatively easily changed as part of the egress path, usually with
iptables & the mangle table, ingress is more challenging.  CAKE is often
used on the WAN interface of a residential gateway where passthrough of
DSCP from the ISP is either missing or set to unhelpful values thus use
of ingress DSCP values for tin selection isn't helpful in that
environment.

An approach to solving the ingress tin selection problem is to use
CAKE's understanding of tc filters.  Naive tc filters could match on
source/destination port numbers and force tin selection that way, but
multiple filters don't scale particularly well as each filter must be
traversed whether it matches or not. e.g. a simple example to map 3
firewall marks to tins:

MAJOR=$( tc qdisc show dev $DEV | head -1 | awk '{print $3}' )
tc filter add dev $DEV parent $MAJOR protocol all handle 0x01 fw action skbedit priority ${MAJOR}1
tc filter add dev $DEV parent $MAJOR protocol all handle 0x02 fw action skbedit priority ${MAJOR}2
tc filter add dev $DEV parent $MAJOR protocol all handle 0x03 fw action skbedit priority ${MAJOR}3

Another option is to use eBPF cls_act with tc filters e.g.

MAJOR=$( tc qdisc show dev $DEV | head -1 | awk '{print $3}' )
tc filter add dev $DEV parent $MAJOR bpf da obj my-bpf-fwmark-to-class.o

This has the disadvantages of a) needing someone to write & maintain
the bpf program, b) a bpf toolchain to compile it and c) needing to
hardcode the major number in the bpf program so it matches the cake
instance (or forcing the cake instance to a particular major number)
since the major number cannot be passed to the bpf program via tc
command line.

As already hinted at by the previous examples, it would be helpful
to associate tins with something that survives the Internet path and
ideally allows tin selection on both egress and ingress.  Netfilter's
conntrack permits setting an identifying mark on a connection which
can also be restored to an ingress packet with tc action connmark e.g.

tc filter add dev eth0 parent ffff: protocol all prio 10 u32 \
	match u32 0 0 flowid 1:1 action connmark action mirred egress redirect dev ifb1

Since tc's connmark action has restored any connmark into skb->mark,
any of the previous solutions are based upon it and in one form or
another copy that mark to the skb->priority field where again CAKE
picks this up.

This change cuts out at least one of the (less intuitive &
non-scalable) middlemen and permit direct access to skb->mark.

Signed-off-by: Kevin Darbyshire-Bryant <ldir@darbyshire-bryant.me.uk>
Signed-off-by: Toke Høiland-Jørgensen <toke@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/include/uapi/linux/pkt_sched.h b/include/uapi/linux/pkt_sched.h
index 1eb572ef3f2775686d4f5c7d0e6c2582a9c16f3b..7ee74c3474bff4b39b11fc48cb6154fdb4b6aad0 100644 (file)
--- a/include/uapi/linux/pkt_sched.h
+++ b/include/uapi/linux/pkt_sched.h
@@ -1021,6 +1021,7 @@ enum {
        TCA_CAKE_INGRESS,
        TCA_CAKE_ACK_FILTER,
        TCA_CAKE_SPLIT_GSO,
+       TCA_CAKE_FWMARK,
        __TCA_CAKE_MAX
 };
 #define TCA_CAKE_MAX   (__TCA_CAKE_MAX - 1)

diff --git a/net/sched/sch_cake.c b/net/sched/sch_cake.c
index 4d688b3b471ba1c59adad296ea20ffc8b0074e05..f1cc4779699b1ab1e34fd0cd33c429db045682d3 100644 (file)
--- a/net/sched/sch_cake.c
+++ b/net/sched/sch_cake.c
@@ -258,7 +258,8 @@ enum {
        CAKE_FLAG_AUTORATE_INGRESS = BIT(1),
        CAKE_FLAG_INGRESS          = BIT(2),
        CAKE_FLAG_WASH             = BIT(3),
-       CAKE_FLAG_SPLIT_GSO        = BIT(4)
+       CAKE_FLAG_SPLIT_GSO        = BIT(4),
+       CAKE_FLAG_FWMARK           = BIT(5)
 };
 
 /* COBALT operates the Codel and BLUE algorithms in parallel, in order to
@@ -1566,12 +1567,20 @@ static struct cake_tin_data *cake_select_tin(struct Qdisc *sch,
                if (q->rate_flags & CAKE_FLAG_WASH)
                        cake_wash_diffserv(skb);
        } else if (q->tin_mode != CAKE_DIFFSERV_BESTEFFORT) {
-               /* extract the Diffserv Precedence field, if it exists */
-               /* and clear DSCP bits if washing */
-               tin = q->tin_index[cake_handle_diffserv(skb,
-                               q->rate_flags & CAKE_FLAG_WASH)];
-               if (unlikely(tin >= q->tin_cnt))
-                       tin = 0;
+               if (q->rate_flags & CAKE_FLAG_FWMARK && /* use fw mark */
+                   skb->mark &&
+                   skb->mark <= q->tin_cnt) {
+                       tin = q->tin_order[skb->mark - 1];
+                       if (q->rate_flags & CAKE_FLAG_WASH)
+                               cake_wash_diffserv(skb);
+               } else {
+                       /* extract the Diffserv Precedence field, if it exists */
+                       /* and clear DSCP bits if washing */
+                       tin = q->tin_index[cake_handle_diffserv(skb,
+                                       q->rate_flags & CAKE_FLAG_WASH)];
+                       if (unlikely(tin >= q->tin_cnt))
+                               tin = 0;
+               }
        } else {
                tin = 0;
                if (q->rate_flags & CAKE_FLAG_WASH)
@@ -2624,6 +2633,13 @@ static int cake_change(struct Qdisc *sch, struct nlattr *opt,
                        q->rate_flags &= ~CAKE_FLAG_SPLIT_GSO;
        }
 
+       if (tb[TCA_CAKE_FWMARK]) {
+               if (!!nla_get_u32(tb[TCA_CAKE_FWMARK]))
+                       q->rate_flags |= CAKE_FLAG_FWMARK;
+               else
+                       q->rate_flags &= ~CAKE_FLAG_FWMARK;
+       }
+
        if (q->tins) {
                sch_tree_lock(sch);
                cake_reconfigure(sch);
@@ -2783,6 +2799,10 @@ static int cake_dump(struct Qdisc *sch, struct sk_buff *skb)
                        !!(q->rate_flags & CAKE_FLAG_SPLIT_GSO)))
                goto nla_put_failure;
 
+       if (nla_put_u32(skb, TCA_CAKE_FWMARK,
+                       !!(q->rate_flags & CAKE_FLAG_FWMARK)))
+               goto nla_put_failure;
+
        return nla_nest_end(skb, opts);
 
 nla_put_failure: