Commit 0d688a0d authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'cls_flower-MPLS' 



Benjamin LaHaise says:

====================
flower: add MPLS matching support

This patch series adds support for parsing MPLS flows in the flow dissector
and the flower classifier.  Each of the MPLS TTL, BOS, TC and Label fields
can be used for matching.

v2: incorporate style feedback, move #defines to linux/include/mpls.h
Note: this omits Jiri's request to remove tabs between the type and
field names in struct declarations.  This would be inconsistent with
numerous other struct definitions.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 3ec21b65 a577d8f7

include/linux/mpls.h

+5 −0
Original line number Diff line number Diff line
@@ -3,4 +3,9 @@ 


#include <uapi/linux/mpls.h>



#define MPLS_TTL_MASK		(MPLS_LS_TTL_MASK >> MPLS_LS_TTL_SHIFT)

#define MPLS_BOS_MASK		(MPLS_LS_S_MASK >> MPLS_LS_S_SHIFT)

#define MPLS_TC_MASK		(MPLS_LS_TC_MASK >> MPLS_LS_TC_SHIFT)

#define MPLS_LABEL_MASK		(MPLS_LS_LABEL_MASK >> MPLS_LS_LABEL_SHIFT)



#endif  /* _LINUX_MPLS_H */

include/net/flow_dissector.h

+8 −0
Original line number Diff line number Diff line
@@ -41,6 +41,13 @@ struct flow_dissector_key_vlan { 
	u16	padding;

};



struct flow_dissector_key_mpls {

	u32	mpls_ttl:8,

		mpls_bos:1,

		mpls_tc:3,

		mpls_label:20;

};



struct flow_dissector_key_keyid {

	__be32	keyid;

};
@@ -169,6 +176,7 @@ enum flow_dissector_key_id { 
	FLOW_DISSECTOR_KEY_ENC_IPV6_ADDRS, /* struct flow_dissector_key_ipv6_addrs */

	FLOW_DISSECTOR_KEY_ENC_CONTROL, /* struct flow_dissector_key_control */

	FLOW_DISSECTOR_KEY_ENC_PORTS, /* struct flow_dissector_key_ports */

	FLOW_DISSECTOR_KEY_MPLS, /* struct flow_dissector_key_mpls */



	FLOW_DISSECTOR_KEY_MAX,

};

include/uapi/linux/pkt_cls.h

+5 −0
Original line number Diff line number Diff line
@@ -432,6 +432,11 @@ enum { 
	TCA_FLOWER_KEY_ARP_THA,		/* ETH_ALEN */

	TCA_FLOWER_KEY_ARP_THA_MASK,	/* ETH_ALEN */



	TCA_FLOWER_KEY_MPLS_TTL,	/* u8 - 8 bits */

	TCA_FLOWER_KEY_MPLS_BOS,	/* u8 - 1 bit */

	TCA_FLOWER_KEY_MPLS_TC,		/* u8 - 3 bits */

	TCA_FLOWER_KEY_MPLS_LABEL,	/* be32 - 20 bits */



	__TCA_FLOWER_MAX,

};

net/core/flow_dissector.c

+22 −3
Original line number Diff line number Diff line
@@ -126,9 +126,11 @@ __skb_flow_dissect_mpls(const struct sk_buff *skb, 
{

	struct flow_dissector_key_keyid *key_keyid;

	struct mpls_label *hdr, _hdr[2];

	u32 entry, label;



	if (!dissector_uses_key(flow_dissector,

				FLOW_DISSECTOR_KEY_MPLS_ENTROPY))

				FLOW_DISSECTOR_KEY_MPLS_ENTROPY) &&

	    !dissector_uses_key(flow_dissector, FLOW_DISSECTOR_KEY_MPLS))

		return FLOW_DISSECT_RET_OUT_GOOD;



	hdr = __skb_header_pointer(skb, nhoff, sizeof(_hdr), data,
@@ -136,8 +138,25 @@ __skb_flow_dissect_mpls(const struct sk_buff *skb, 
	if (!hdr)

		return FLOW_DISSECT_RET_OUT_BAD;



	if ((ntohl(hdr[0].entry) & MPLS_LS_LABEL_MASK) >>

	    MPLS_LS_LABEL_SHIFT == MPLS_LABEL_ENTROPY) {

	entry = ntohl(hdr[0].entry);

	label = (entry & MPLS_LS_LABEL_MASK) >> MPLS_LS_LABEL_SHIFT;



	if (dissector_uses_key(flow_dissector, FLOW_DISSECTOR_KEY_MPLS)) {

		struct flow_dissector_key_mpls *key_mpls;



		key_mpls = skb_flow_dissector_target(flow_dissector,

						     FLOW_DISSECTOR_KEY_MPLS,

						     target_container);

		key_mpls->mpls_label = label;

		key_mpls->mpls_ttl = (entry & MPLS_LS_TTL_MASK)

					>> MPLS_LS_TTL_SHIFT;

		key_mpls->mpls_tc = (entry & MPLS_LS_TC_MASK)

					>> MPLS_LS_TC_SHIFT;

		key_mpls->mpls_bos = (entry & MPLS_LS_S_MASK)

					>> MPLS_LS_S_SHIFT;

	}



	if (label == MPLS_LABEL_ENTROPY) {

		key_keyid = skb_flow_dissector_target(flow_dissector,

						      FLOW_DISSECTOR_KEY_MPLS_ENTROPY,

						      target_container);

net/sched/cls_flower.c

+74 −0
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ 
#include <linux/if_ether.h>

#include <linux/in6.h>

#include <linux/ip.h>

#include <linux/mpls.h>



#include <net/sch_generic.h>

#include <net/pkt_cls.h>
@@ -47,6 +48,7 @@ struct fl_flow_key { 
		struct flow_dissector_key_ipv6_addrs enc_ipv6;

	};

	struct flow_dissector_key_ports enc_tp;

	struct flow_dissector_key_mpls mpls;

} __aligned(BITS_PER_LONG / 8); /* Ensure that we can do comparisons as longs. */



struct fl_flow_mask_range {
@@ -418,6 +420,10 @@ static const struct nla_policy fl_policy[TCA_FLOWER_MAX + 1] = { 
	[TCA_FLOWER_KEY_ARP_SHA_MASK]	= { .len = ETH_ALEN },

	[TCA_FLOWER_KEY_ARP_THA]	= { .len = ETH_ALEN },

	[TCA_FLOWER_KEY_ARP_THA_MASK]	= { .len = ETH_ALEN },

	[TCA_FLOWER_KEY_MPLS_TTL]	= { .type = NLA_U8 },

	[TCA_FLOWER_KEY_MPLS_BOS]	= { .type = NLA_U8 },

	[TCA_FLOWER_KEY_MPLS_TC]	= { .type = NLA_U8 },

	[TCA_FLOWER_KEY_MPLS_LABEL]	= { .type = NLA_U32 },

};



static void fl_set_key_val(struct nlattr **tb,
@@ -433,6 +439,31 @@ static void fl_set_key_val(struct nlattr **tb, 
		memcpy(mask, nla_data(tb[mask_type]), len);

}



static void fl_set_key_mpls(struct nlattr **tb,

			    struct flow_dissector_key_mpls *key_val,

			    struct flow_dissector_key_mpls *key_mask)

{

	if (tb[TCA_FLOWER_KEY_MPLS_TTL]) {

		key_val->mpls_ttl = nla_get_u8(tb[TCA_FLOWER_KEY_MPLS_TTL]);

		key_mask->mpls_ttl = MPLS_TTL_MASK;

	}

	if (tb[TCA_FLOWER_KEY_MPLS_BOS]) {

		key_val->mpls_bos = nla_get_u8(tb[TCA_FLOWER_KEY_MPLS_BOS]);

		key_mask->mpls_bos = MPLS_BOS_MASK;

	}

	if (tb[TCA_FLOWER_KEY_MPLS_TC]) {

		key_val->mpls_tc =

			nla_get_u8(tb[TCA_FLOWER_KEY_MPLS_TC]) & MPLS_TC_MASK;

		key_mask->mpls_tc = MPLS_TC_MASK;

	}

	if (tb[TCA_FLOWER_KEY_MPLS_LABEL]) {

		key_val->mpls_label =

			nla_get_u32(tb[TCA_FLOWER_KEY_MPLS_LABEL]) &

			MPLS_LABEL_MASK;

		key_mask->mpls_label = MPLS_LABEL_MASK;

	}

}



static void fl_set_key_vlan(struct nlattr **tb,

			    struct flow_dissector_key_vlan *key_val,

			    struct flow_dissector_key_vlan *key_mask)
@@ -589,6 +620,9 @@ static int fl_set_key(struct net *net, struct nlattr **tb, 
			       &mask->icmp.code,

			       TCA_FLOWER_KEY_ICMPV6_CODE_MASK,

			       sizeof(key->icmp.code));

	} else if (key->basic.n_proto == htons(ETH_P_MPLS_UC) ||

		   key->basic.n_proto == htons(ETH_P_MPLS_MC)) {

		fl_set_key_mpls(tb, &key->mpls, &mask->mpls);

	} else if (key->basic.n_proto == htons(ETH_P_ARP) ||

		   key->basic.n_proto == htons(ETH_P_RARP)) {

		fl_set_key_val(tb, &key->arp.sip, TCA_FLOWER_KEY_ARP_SIP,
@@ -724,6 +758,8 @@ static void fl_init_dissector(struct cls_fl_head *head, 
			     FLOW_DISSECTOR_KEY_ICMP, icmp);

	FL_KEY_SET_IF_MASKED(&mask->key, keys, cnt,

			     FLOW_DISSECTOR_KEY_ARP, arp);

	FL_KEY_SET_IF_MASKED(&mask->key, keys, cnt,

			     FLOW_DISSECTOR_KEY_MPLS, mpls);

	FL_KEY_SET_IF_MASKED(&mask->key, keys, cnt,

			     FLOW_DISSECTOR_KEY_VLAN, vlan);

	FL_KEY_SET_IF_MASKED(&mask->key, keys, cnt,
@@ -991,6 +1027,41 @@ static int fl_dump_key_val(struct sk_buff *skb, 
	return 0;

}



static int fl_dump_key_mpls(struct sk_buff *skb,

			    struct flow_dissector_key_mpls *mpls_key,

			    struct flow_dissector_key_mpls *mpls_mask)

{

	int err;



	if (!memchr_inv(mpls_mask, 0, sizeof(*mpls_mask)))

		return 0;

	if (mpls_mask->mpls_ttl) {

		err = nla_put_u8(skb, TCA_FLOWER_KEY_MPLS_TTL,

				 mpls_key->mpls_ttl);

		if (err)

			return err;

	}

	if (mpls_mask->mpls_tc) {

		err = nla_put_u8(skb, TCA_FLOWER_KEY_MPLS_TC,

				 mpls_key->mpls_tc);

		if (err)

			return err;

	}

	if (mpls_mask->mpls_label) {

		err = nla_put_u32(skb, TCA_FLOWER_KEY_MPLS_LABEL,

				  mpls_key->mpls_label);

		if (err)

			return err;

	}

	if (mpls_mask->mpls_bos) {

		err = nla_put_u8(skb, TCA_FLOWER_KEY_MPLS_BOS,

				 mpls_key->mpls_bos);

		if (err)

			return err;

	}

	return 0;

}



static int fl_dump_key_vlan(struct sk_buff *skb,

			    struct flow_dissector_key_vlan *vlan_key,

			    struct flow_dissector_key_vlan *vlan_mask)
@@ -1096,6 +1167,9 @@ static int fl_dump(struct net *net, struct tcf_proto *tp, unsigned long fh, 
			    sizeof(key->basic.n_proto)))

		goto nla_put_failure;



	if (fl_dump_key_mpls(skb, &key->mpls, &mask->mpls))

		goto nla_put_failure;



	if (fl_dump_key_vlan(skb, &key->vlan, &mask->vlan))

		goto nla_put_failure;

CRA Git | Maintained and supported by SUSTech CRA and CCSE