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

Merge branch 'net-sched-support-vxlan-and-erspan-options' 

Xin Long says:

====================
net: sched: support vxlan and erspan options

This patchset is to add vxlan and erspan options support in
cls_flower and act_tunnel_key. The form is pretty much like
geneve_opts in:

  https://patchwork.ozlabs.org/patch/935272/
  https://patchwork.ozlabs.org/patch/954564/



but only one option is allowed for vxlan and erspan.

v1->v2:
  - see each patch changelog.
====================

Acked-by: default avatarJakub Kicinski <jakub.kicinski@netronome.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 0617aa98 79b1011c

include/uapi/linux/pkt_cls.h

+29 −0
Original line number Diff line number Diff line
@@ -571,6 +571,14 @@ enum { 
					 * TCA_FLOWER_KEY_ENC_OPT_GENEVE_

					 * attributes

					 */

	TCA_FLOWER_KEY_ENC_OPTS_VXLAN,	/* Nested

					 * TCA_FLOWER_KEY_ENC_OPT_VXLAN_

					 * attributes

					 */

	TCA_FLOWER_KEY_ENC_OPTS_ERSPAN,	/* Nested

					 * TCA_FLOWER_KEY_ENC_OPT_ERSPAN_

					 * attributes

					 */

	__TCA_FLOWER_KEY_ENC_OPTS_MAX,

};
@@ -588,6 +596,27 @@ enum { 
#define TCA_FLOWER_KEY_ENC_OPT_GENEVE_MAX \

		(__TCA_FLOWER_KEY_ENC_OPT_GENEVE_MAX - 1)



enum {

	TCA_FLOWER_KEY_ENC_OPT_VXLAN_UNSPEC,

	TCA_FLOWER_KEY_ENC_OPT_VXLAN_GBP,		/* u32 */

	__TCA_FLOWER_KEY_ENC_OPT_VXLAN_MAX,

};



#define TCA_FLOWER_KEY_ENC_OPT_VXLAN_MAX \

		(__TCA_FLOWER_KEY_ENC_OPT_VXLAN_MAX - 1)



enum {

	TCA_FLOWER_KEY_ENC_OPT_ERSPAN_UNSPEC,

	TCA_FLOWER_KEY_ENC_OPT_ERSPAN_VER,              /* u8 */

	TCA_FLOWER_KEY_ENC_OPT_ERSPAN_INDEX,            /* be32 */

	TCA_FLOWER_KEY_ENC_OPT_ERSPAN_DIR,              /* u8 */

	TCA_FLOWER_KEY_ENC_OPT_ERSPAN_HWID,             /* u8 */

	__TCA_FLOWER_KEY_ENC_OPT_ERSPAN_MAX,

};



#define TCA_FLOWER_KEY_ENC_OPT_ERSPAN_MAX \

		(__TCA_FLOWER_KEY_ENC_OPT_ERSPAN_MAX - 1)



enum {

	TCA_FLOWER_KEY_FLAGS_IS_FRAGMENT = (1 << 0),

	TCA_FLOWER_KEY_FLAGS_FRAG_IS_FIRST = (1 << 1),

include/uapi/linux/tc_act/tc_tunnel_key.h

+29 −0
Original line number Diff line number Diff line
@@ -50,6 +50,14 @@ enum { 
						 * TCA_TUNNEL_KEY_ENC_OPTS_

						 * attributes

						 */

	TCA_TUNNEL_KEY_ENC_OPTS_VXLAN,		/* Nested

						 * TCA_TUNNEL_KEY_ENC_OPTS_

						 * attributes

						 */

	TCA_TUNNEL_KEY_ENC_OPTS_ERSPAN,		/* Nested

						 * TCA_TUNNEL_KEY_ENC_OPTS_

						 * attributes

						 */

	__TCA_TUNNEL_KEY_ENC_OPTS_MAX,

};
@@ -67,4 +75,25 @@ enum { 
#define TCA_TUNNEL_KEY_ENC_OPT_GENEVE_MAX \

	(__TCA_TUNNEL_KEY_ENC_OPT_GENEVE_MAX - 1)



enum {

	TCA_TUNNEL_KEY_ENC_OPT_VXLAN_UNSPEC,

	TCA_TUNNEL_KEY_ENC_OPT_VXLAN_GBP,		/* u32 */

	__TCA_TUNNEL_KEY_ENC_OPT_VXLAN_MAX,

};



#define TCA_TUNNEL_KEY_ENC_OPT_VXLAN_MAX \

	(__TCA_TUNNEL_KEY_ENC_OPT_VXLAN_MAX - 1)



enum {

	TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_UNSPEC,

	TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_VER,		/* u8 */

	TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_INDEX,		/* be32 */

	TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_DIR,		/* u8 */

	TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_HWID,		/* u8 */

	__TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_MAX,

};



#define TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_MAX \

	(__TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_MAX - 1)



#endif

net/sched/act_tunnel_key.c

+202 −1
Original line number Diff line number Diff line
@@ -10,6 +10,8 @@ 
#include <linux/skbuff.h>

#include <linux/rtnetlink.h>

#include <net/geneve.h>

#include <net/vxlan.h>

#include <net/erspan.h>

#include <net/netlink.h>

#include <net/pkt_sched.h>

#include <net/dst.h>
@@ -53,7 +55,11 @@ static int tunnel_key_act(struct sk_buff *skb, const struct tc_action *a, 


static const struct nla_policy

enc_opts_policy[TCA_TUNNEL_KEY_ENC_OPTS_MAX + 1] = {

	[TCA_TUNNEL_KEY_ENC_OPTS_UNSPEC]	= {

		.strict_start_type = TCA_TUNNEL_KEY_ENC_OPTS_VXLAN },

	[TCA_TUNNEL_KEY_ENC_OPTS_GENEVE]	= { .type = NLA_NESTED },

	[TCA_TUNNEL_KEY_ENC_OPTS_VXLAN]		= { .type = NLA_NESTED },

	[TCA_TUNNEL_KEY_ENC_OPTS_ERSPAN]	= { .type = NLA_NESTED },

};



static const struct nla_policy
@@ -64,6 +70,19 @@ geneve_opt_policy[TCA_TUNNEL_KEY_ENC_OPT_GENEVE_MAX + 1] = { 
						       .len = 128 },

};



static const struct nla_policy

vxlan_opt_policy[TCA_TUNNEL_KEY_ENC_OPT_VXLAN_MAX + 1] = {

	[TCA_TUNNEL_KEY_ENC_OPT_VXLAN_GBP]	   = { .type = NLA_U32 },

};



static const struct nla_policy

erspan_opt_policy[TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_MAX + 1] = {

	[TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_VER]	   = { .type = NLA_U8 },

	[TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_INDEX]	   = { .type = NLA_U32 },

	[TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_DIR]	   = { .type = NLA_U8 },

	[TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_HWID]	   = { .type = NLA_U8 },

};



static int

tunnel_key_copy_geneve_opt(const struct nlattr *nla, void *dst, int dst_len,

			   struct netlink_ext_ack *extack)
@@ -116,10 +135,89 @@ tunnel_key_copy_geneve_opt(const struct nlattr *nla, void *dst, int dst_len, 
	return opt_len;

}



static int

tunnel_key_copy_vxlan_opt(const struct nlattr *nla, void *dst, int dst_len,

			  struct netlink_ext_ack *extack)

{

	struct nlattr *tb[TCA_TUNNEL_KEY_ENC_OPT_VXLAN_MAX + 1];

	int err;



	err = nla_parse_nested(tb, TCA_TUNNEL_KEY_ENC_OPT_VXLAN_MAX, nla,

			       vxlan_opt_policy, extack);

	if (err < 0)

		return err;



	if (!tb[TCA_TUNNEL_KEY_ENC_OPT_VXLAN_GBP]) {

		NL_SET_ERR_MSG(extack, "Missing tunnel key vxlan option gbp");

		return -EINVAL;

	}



	if (dst) {

		struct vxlan_metadata *md = dst;



		md->gbp = nla_get_u32(tb[TCA_TUNNEL_KEY_ENC_OPT_VXLAN_GBP]);

	}



	return sizeof(struct vxlan_metadata);

}



static int

tunnel_key_copy_erspan_opt(const struct nlattr *nla, void *dst, int dst_len,

			   struct netlink_ext_ack *extack)

{

	struct nlattr *tb[TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_MAX + 1];

	int err;

	u8 ver;



	err = nla_parse_nested(tb, TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_MAX, nla,

			       erspan_opt_policy, extack);

	if (err < 0)

		return err;



	if (!tb[TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_VER]) {

		NL_SET_ERR_MSG(extack, "Missing tunnel key erspan option ver");

		return -EINVAL;

	}



	ver = nla_get_u8(tb[TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_VER]);

	if (ver == 1) {

		if (!tb[TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_INDEX]) {

			NL_SET_ERR_MSG(extack, "Missing tunnel key erspan option index");

			return -EINVAL;

		}

	} else if (ver == 2) {

		if (!tb[TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_DIR] ||

		    !tb[TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_HWID]) {

			NL_SET_ERR_MSG(extack, "Missing tunnel key erspan option dir or hwid");

			return -EINVAL;

		}

	} else {

		NL_SET_ERR_MSG(extack, "Tunnel key erspan option ver is incorrect");

		return -EINVAL;

	}



	if (dst) {

		struct erspan_metadata *md = dst;



		md->version = ver;

		if (ver == 1) {

			nla = tb[TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_INDEX];

			md->u.index = nla_get_be32(nla);

		} else {

			nla = tb[TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_DIR];

			md->u.md2.dir = nla_get_u8(nla);

			nla = tb[TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_HWID];

			set_hwid(&md->u.md2, nla_get_u8(nla));

		}

	}



	return sizeof(struct erspan_metadata);

}



static int tunnel_key_copy_opts(const struct nlattr *nla, u8 *dst,

				int dst_len, struct netlink_ext_ack *extack)

{

	int err, rem, opt_len, len = nla_len(nla), opts_len = 0;

	int err, rem, opt_len, len = nla_len(nla), opts_len = 0, type = 0;

	const struct nlattr *attr, *head = nla_data(nla);



	err = nla_validate_deprecated(head, len, TCA_TUNNEL_KEY_ENC_OPTS_MAX,
@@ -130,6 +228,10 @@ static int tunnel_key_copy_opts(const struct nlattr *nla, u8 *dst, 
	nla_for_each_attr(attr, head, len, rem) {

		switch (nla_type(attr)) {

		case TCA_TUNNEL_KEY_ENC_OPTS_GENEVE:

			if (type && type != TUNNEL_GENEVE_OPT) {

				NL_SET_ERR_MSG(extack, "Duplicate type for geneve options");

				return -EINVAL;

			}

			opt_len = tunnel_key_copy_geneve_opt(attr, dst,

							     dst_len, extack);

			if (opt_len < 0)
@@ -139,6 +241,31 @@ static int tunnel_key_copy_opts(const struct nlattr *nla, u8 *dst, 
				dst_len -= opt_len;

				dst += opt_len;

			}

			type = TUNNEL_GENEVE_OPT;

			break;

		case TCA_TUNNEL_KEY_ENC_OPTS_VXLAN:

			if (type) {

				NL_SET_ERR_MSG(extack, "Duplicate type for vxlan options");

				return -EINVAL;

			}

			opt_len = tunnel_key_copy_vxlan_opt(attr, dst,

							    dst_len, extack);

			if (opt_len < 0)

				return opt_len;

			opts_len += opt_len;

			type = TUNNEL_VXLAN_OPT;

			break;

		case TCA_TUNNEL_KEY_ENC_OPTS_ERSPAN:

			if (type) {

				NL_SET_ERR_MSG(extack, "Duplicate type for erspan options");

				return -EINVAL;

			}

			opt_len = tunnel_key_copy_erspan_opt(attr, dst,

							     dst_len, extack);

			if (opt_len < 0)

				return opt_len;

			opts_len += opt_len;

			type = TUNNEL_ERSPAN_OPT;

			break;

		}

	}
@@ -174,6 +301,22 @@ static int tunnel_key_opts_set(struct nlattr *nla, struct ip_tunnel_info *info, 
					    opts_len, extack);

#else

		return -EAFNOSUPPORT;

#endif

	case TCA_TUNNEL_KEY_ENC_OPTS_VXLAN:

#if IS_ENABLED(CONFIG_INET)

		info->key.tun_flags |= TUNNEL_VXLAN_OPT;

		return tunnel_key_copy_opts(nla, ip_tunnel_info_opts(info),

					    opts_len, extack);

#else

		return -EAFNOSUPPORT;

#endif

	case TCA_TUNNEL_KEY_ENC_OPTS_ERSPAN:

#if IS_ENABLED(CONFIG_INET)

		info->key.tun_flags |= TUNNEL_ERSPAN_OPT;

		return tunnel_key_copy_opts(nla, ip_tunnel_info_opts(info),

					    opts_len, extack);

#else

		return -EAFNOSUPPORT;

#endif

	default:

		NL_SET_ERR_MSG(extack, "Cannot set tunnel options for unknown tunnel type");
@@ -451,6 +594,56 @@ static int tunnel_key_geneve_opts_dump(struct sk_buff *skb, 
	return 0;

}



static int tunnel_key_vxlan_opts_dump(struct sk_buff *skb,

				      const struct ip_tunnel_info *info)

{

	struct vxlan_metadata *md = (struct vxlan_metadata *)(info + 1);

	struct nlattr *start;



	start = nla_nest_start_noflag(skb, TCA_TUNNEL_KEY_ENC_OPTS_VXLAN);

	if (!start)

		return -EMSGSIZE;



	if (nla_put_u32(skb, TCA_TUNNEL_KEY_ENC_OPT_VXLAN_GBP, md->gbp)) {

		nla_nest_cancel(skb, start);

		return -EMSGSIZE;

	}



	nla_nest_end(skb, start);

	return 0;

}



static int tunnel_key_erspan_opts_dump(struct sk_buff *skb,

				       const struct ip_tunnel_info *info)

{

	struct erspan_metadata *md = (struct erspan_metadata *)(info + 1);

	struct nlattr *start;



	start = nla_nest_start_noflag(skb, TCA_TUNNEL_KEY_ENC_OPTS_ERSPAN);

	if (!start)

		return -EMSGSIZE;



	if (nla_put_u8(skb, TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_VER, md->version))

		goto err;



	if (md->version == 1 &&

	    nla_put_be32(skb, TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_INDEX, md->u.index))

		goto err;



	if (md->version == 2 &&

	    (nla_put_u8(skb, TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_DIR,

			md->u.md2.dir) ||

	     nla_put_u8(skb, TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_HWID,

			get_hwid(&md->u.md2))))

		goto err;



	nla_nest_end(skb, start);

	return 0;

err:

	nla_nest_cancel(skb, start);

	return -EMSGSIZE;

}



static int tunnel_key_opts_dump(struct sk_buff *skb,

				const struct ip_tunnel_info *info)

{
@@ -468,6 +661,14 @@ static int tunnel_key_opts_dump(struct sk_buff *skb, 
		err = tunnel_key_geneve_opts_dump(skb, info);

		if (err)

			goto err_out;

	} else if (info->key.tun_flags & TUNNEL_VXLAN_OPT) {

		err = tunnel_key_vxlan_opts_dump(skb, info);

		if (err)

			goto err_out;

	} else if (info->key.tun_flags & TUNNEL_ERSPAN_OPT) {

		err = tunnel_key_erspan_opts_dump(skb, info);

		if (err)

			goto err_out;

	} else {

err_out:

		nla_nest_cancel(skb, start);

net/sched/cls_flower.c

+254 −0
Original line number Diff line number Diff line
@@ -22,6 +22,8 @@ 
#include <net/ip.h>

#include <net/flow_dissector.h>

#include <net/geneve.h>

#include <net/vxlan.h>

#include <net/erspan.h>



#include <net/dst.h>

#include <net/dst_metadata.h>
@@ -688,7 +690,11 @@ static const struct nla_policy fl_policy[TCA_FLOWER_MAX + 1] = { 


static const struct nla_policy

enc_opts_policy[TCA_FLOWER_KEY_ENC_OPTS_MAX + 1] = {

	[TCA_FLOWER_KEY_ENC_OPTS_UNSPEC]        = {

		.strict_start_type = TCA_FLOWER_KEY_ENC_OPTS_VXLAN },

	[TCA_FLOWER_KEY_ENC_OPTS_GENEVE]        = { .type = NLA_NESTED },

	[TCA_FLOWER_KEY_ENC_OPTS_VXLAN]         = { .type = NLA_NESTED },

	[TCA_FLOWER_KEY_ENC_OPTS_ERSPAN]        = { .type = NLA_NESTED },

};



static const struct nla_policy
@@ -699,6 +705,19 @@ geneve_opt_policy[TCA_FLOWER_KEY_ENC_OPT_GENEVE_MAX + 1] = { 
						       .len = 128 },

};



static const struct nla_policy

vxlan_opt_policy[TCA_FLOWER_KEY_ENC_OPT_VXLAN_MAX + 1] = {

	[TCA_FLOWER_KEY_ENC_OPT_VXLAN_GBP]         = { .type = NLA_U32 },

};



static const struct nla_policy

erspan_opt_policy[TCA_FLOWER_KEY_ENC_OPT_ERSPAN_MAX + 1] = {

	[TCA_FLOWER_KEY_ENC_OPT_ERSPAN_VER]        = { .type = NLA_U8 },

	[TCA_FLOWER_KEY_ENC_OPT_ERSPAN_INDEX]      = { .type = NLA_U32 },

	[TCA_FLOWER_KEY_ENC_OPT_ERSPAN_DIR]        = { .type = NLA_U8 },

	[TCA_FLOWER_KEY_ENC_OPT_ERSPAN_HWID]       = { .type = NLA_U8 },

};



static void fl_set_key_val(struct nlattr **tb,

			   void *val, int val_type,

			   void *mask, int mask_type, int len)
@@ -928,6 +947,105 @@ static int fl_set_geneve_opt(const struct nlattr *nla, struct fl_flow_key *key, 
	return sizeof(struct geneve_opt) + data_len;

}



static int fl_set_vxlan_opt(const struct nlattr *nla, struct fl_flow_key *key,

			    int depth, int option_len,

			    struct netlink_ext_ack *extack)

{

	struct nlattr *tb[TCA_FLOWER_KEY_ENC_OPT_VXLAN_MAX + 1];

	struct vxlan_metadata *md;

	int err;



	md = (struct vxlan_metadata *)&key->enc_opts.data[key->enc_opts.len];

	memset(md, 0xff, sizeof(*md));



	if (!depth)

		return sizeof(*md);



	if (nla_type(nla) != TCA_FLOWER_KEY_ENC_OPTS_VXLAN) {

		NL_SET_ERR_MSG(extack, "Non-vxlan option type for mask");

		return -EINVAL;

	}



	err = nla_parse_nested(tb, TCA_FLOWER_KEY_ENC_OPT_VXLAN_MAX, nla,

			       vxlan_opt_policy, extack);

	if (err < 0)

		return err;



	if (!option_len && !tb[TCA_FLOWER_KEY_ENC_OPT_VXLAN_GBP]) {

		NL_SET_ERR_MSG(extack, "Missing tunnel key vxlan option gbp");

		return -EINVAL;

	}



	if (tb[TCA_FLOWER_KEY_ENC_OPT_VXLAN_GBP])

		md->gbp = nla_get_u32(tb[TCA_FLOWER_KEY_ENC_OPT_VXLAN_GBP]);



	return sizeof(*md);

}



static int fl_set_erspan_opt(const struct nlattr *nla, struct fl_flow_key *key,

			     int depth, int option_len,

			     struct netlink_ext_ack *extack)

{

	struct nlattr *tb[TCA_FLOWER_KEY_ENC_OPT_ERSPAN_MAX + 1];

	struct erspan_metadata *md;

	int err;



	md = (struct erspan_metadata *)&key->enc_opts.data[key->enc_opts.len];

	memset(md, 0xff, sizeof(*md));

	md->version = 1;



	if (!depth)

		return sizeof(*md);



	if (nla_type(nla) != TCA_FLOWER_KEY_ENC_OPTS_ERSPAN) {

		NL_SET_ERR_MSG(extack, "Non-erspan option type for mask");

		return -EINVAL;

	}



	err = nla_parse_nested(tb, TCA_FLOWER_KEY_ENC_OPT_ERSPAN_MAX, nla,

			       erspan_opt_policy, extack);

	if (err < 0)

		return err;



	if (!option_len && !tb[TCA_FLOWER_KEY_ENC_OPT_ERSPAN_VER]) {

		NL_SET_ERR_MSG(extack, "Missing tunnel key erspan option ver");

		return -EINVAL;

	}



	if (tb[TCA_FLOWER_KEY_ENC_OPT_ERSPAN_VER])

		md->version = nla_get_u8(tb[TCA_FLOWER_KEY_ENC_OPT_ERSPAN_VER]);



	if (md->version == 1) {

		if (!option_len && !tb[TCA_FLOWER_KEY_ENC_OPT_ERSPAN_INDEX]) {

			NL_SET_ERR_MSG(extack, "Missing tunnel key erspan option index");

			return -EINVAL;

		}

		if (tb[TCA_FLOWER_KEY_ENC_OPT_ERSPAN_INDEX]) {

			nla = tb[TCA_FLOWER_KEY_ENC_OPT_ERSPAN_INDEX];

			md->u.index = nla_get_be32(nla);

		}

	} else if (md->version == 2) {

		if (!option_len && (!tb[TCA_FLOWER_KEY_ENC_OPT_ERSPAN_DIR] ||

				    !tb[TCA_FLOWER_KEY_ENC_OPT_ERSPAN_HWID])) {

			NL_SET_ERR_MSG(extack, "Missing tunnel key erspan option dir or hwid");

			return -EINVAL;

		}

		if (tb[TCA_FLOWER_KEY_ENC_OPT_ERSPAN_DIR]) {

			nla = tb[TCA_FLOWER_KEY_ENC_OPT_ERSPAN_DIR];

			md->u.md2.dir = nla_get_u8(nla);

		}

		if (tb[TCA_FLOWER_KEY_ENC_OPT_ERSPAN_HWID]) {

			nla = tb[TCA_FLOWER_KEY_ENC_OPT_ERSPAN_HWID];

			set_hwid(&md->u.md2, nla_get_u8(nla));

		}

	} else {

		NL_SET_ERR_MSG(extack, "Tunnel key erspan option ver is incorrect");

		return -EINVAL;

	}



	return sizeof(*md);

}



static int fl_set_enc_opt(struct nlattr **tb, struct fl_flow_key *key,

			  struct fl_flow_key *mask,

			  struct netlink_ext_ack *extack)
@@ -958,6 +1076,11 @@ static int fl_set_enc_opt(struct nlattr **tb, struct fl_flow_key *key, 
			  nla_len(tb[TCA_FLOWER_KEY_ENC_OPTS]), key_depth) {

		switch (nla_type(nla_opt_key)) {

		case TCA_FLOWER_KEY_ENC_OPTS_GENEVE:

			if (key->enc_opts.dst_opt_type &&

			    key->enc_opts.dst_opt_type != TUNNEL_GENEVE_OPT) {

				NL_SET_ERR_MSG(extack, "Duplicate type for geneve options");

				return -EINVAL;

			}

			option_len = 0;

			key->enc_opts.dst_opt_type = TUNNEL_GENEVE_OPT;

			option_len = fl_set_geneve_opt(nla_opt_key, key,
@@ -983,6 +1106,72 @@ static int fl_set_enc_opt(struct nlattr **tb, struct fl_flow_key *key, 
				return -EINVAL;

			}



			if (msk_depth)

				nla_opt_msk = nla_next(nla_opt_msk, &msk_depth);

			break;

		case TCA_FLOWER_KEY_ENC_OPTS_VXLAN:

			if (key->enc_opts.dst_opt_type) {

				NL_SET_ERR_MSG(extack, "Duplicate type for vxlan options");

				return -EINVAL;

			}

			option_len = 0;

			key->enc_opts.dst_opt_type = TUNNEL_VXLAN_OPT;

			option_len = fl_set_vxlan_opt(nla_opt_key, key,

						      key_depth, option_len,

						      extack);

			if (option_len < 0)

				return option_len;



			key->enc_opts.len += option_len;

			/* At the same time we need to parse through the mask

			 * in order to verify exact and mask attribute lengths.

			 */

			mask->enc_opts.dst_opt_type = TUNNEL_VXLAN_OPT;

			option_len = fl_set_vxlan_opt(nla_opt_msk, mask,

						      msk_depth, option_len,

						      extack);

			if (option_len < 0)

				return option_len;



			mask->enc_opts.len += option_len;

			if (key->enc_opts.len != mask->enc_opts.len) {

				NL_SET_ERR_MSG(extack, "Key and mask miss aligned");

				return -EINVAL;

			}



			if (msk_depth)

				nla_opt_msk = nla_next(nla_opt_msk, &msk_depth);

			break;

		case TCA_FLOWER_KEY_ENC_OPTS_ERSPAN:

			if (key->enc_opts.dst_opt_type) {

				NL_SET_ERR_MSG(extack, "Duplicate type for erspan options");

				return -EINVAL;

			}

			option_len = 0;

			key->enc_opts.dst_opt_type = TUNNEL_ERSPAN_OPT;

			option_len = fl_set_erspan_opt(nla_opt_key, key,

						       key_depth, option_len,

						       extack);

			if (option_len < 0)

				return option_len;



			key->enc_opts.len += option_len;

			/* At the same time we need to parse through the mask

			 * in order to verify exact and mask attribute lengths.

			 */

			mask->enc_opts.dst_opt_type = TUNNEL_ERSPAN_OPT;

			option_len = fl_set_erspan_opt(nla_opt_msk, mask,

						       msk_depth, option_len,

						       extack);

			if (option_len < 0)

				return option_len;



			mask->enc_opts.len += option_len;

			if (key->enc_opts.len != mask->enc_opts.len) {

				NL_SET_ERR_MSG(extack, "Key and mask miss aligned");

				return -EINVAL;

			}



			if (msk_depth)

				nla_opt_msk = nla_next(nla_opt_msk, &msk_depth);

			break;
@@ -2135,6 +2324,61 @@ nla_put_failure: 
	return -EMSGSIZE;

}



static int fl_dump_key_vxlan_opt(struct sk_buff *skb,

				 struct flow_dissector_key_enc_opts *enc_opts)

{

	struct vxlan_metadata *md;

	struct nlattr *nest;



	nest = nla_nest_start_noflag(skb, TCA_FLOWER_KEY_ENC_OPTS_VXLAN);

	if (!nest)

		goto nla_put_failure;



	md = (struct vxlan_metadata *)&enc_opts->data[0];

	if (nla_put_u32(skb, TCA_FLOWER_KEY_ENC_OPT_VXLAN_GBP, md->gbp))

		goto nla_put_failure;



	nla_nest_end(skb, nest);

	return 0;



nla_put_failure:

	nla_nest_cancel(skb, nest);

	return -EMSGSIZE;

}



static int fl_dump_key_erspan_opt(struct sk_buff *skb,

				  struct flow_dissector_key_enc_opts *enc_opts)

{

	struct erspan_metadata *md;

	struct nlattr *nest;



	nest = nla_nest_start_noflag(skb, TCA_FLOWER_KEY_ENC_OPTS_ERSPAN);

	if (!nest)

		goto nla_put_failure;



	md = (struct erspan_metadata *)&enc_opts->data[0];

	if (nla_put_u8(skb, TCA_FLOWER_KEY_ENC_OPT_ERSPAN_VER, md->version))

		goto nla_put_failure;



	if (md->version == 1 &&

	    nla_put_be32(skb, TCA_FLOWER_KEY_ENC_OPT_ERSPAN_INDEX, md->u.index))

		goto nla_put_failure;



	if (md->version == 2 &&

	    (nla_put_u8(skb, TCA_FLOWER_KEY_ENC_OPT_ERSPAN_DIR,

			md->u.md2.dir) ||

	     nla_put_u8(skb, TCA_FLOWER_KEY_ENC_OPT_ERSPAN_HWID,

			get_hwid(&md->u.md2))))

		goto nla_put_failure;



	nla_nest_end(skb, nest);

	return 0;



nla_put_failure:

	nla_nest_cancel(skb, nest);

	return -EMSGSIZE;

}



static int fl_dump_key_ct(struct sk_buff *skb,

			  struct flow_dissector_key_ct *key,

			  struct flow_dissector_key_ct *mask)
@@ -2188,6 +2432,16 @@ static int fl_dump_key_options(struct sk_buff *skb, int enc_opt_type, 
		if (err)

			goto nla_put_failure;

		break;

	case TUNNEL_VXLAN_OPT:

		err = fl_dump_key_vxlan_opt(skb, enc_opts);

		if (err)

			goto nla_put_failure;

		break;

	case TUNNEL_ERSPAN_OPT:

		err = fl_dump_key_erspan_opt(skb, enc_opts);

		if (err)

			goto nla_put_failure;

		break;

	default:

		goto nla_put_failure;

	}

CRA Git | Maintained and supported by SUSTech CRA and CCSE