Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

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

Merge branch 'cls_flower-flags' 



Or Gerlitz says:

====================
net/sched: cls_flower: Add support for matching on dissection flags

This series add the UAPI to provide set of flags for matching, where the
flags provided from user-space are mapped to flow-dissector flags.

The 1st flag allows to match on whether the packet is an
IP fragment and corresponds to the FLOW_DIS_IS_FRAGMENT flag.

v2->v3:
  - replace BIT() with << (kbuild test robot)

v1->v2:
 - dropped the flow dissector patch (#1) as no changes are needed there (Jiri)
 - applied code review comments from Jiri to the flower patch
====================

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

drivers/net/ethernet/mellanox/mlx5/core/en_tc.c

+12 −0
Original line number Original line Diff line number Diff line
@@ -31,6 +31,7 @@ 
 */

 */





#include <net/flow_dissector.h>

#include <net/flow_dissector.h>

#include <net/sch_generic.h>

#include <net/pkt_cls.h>

#include <net/pkt_cls.h>

#include <net/tc_act/tc_gact.h>

#include <net/tc_act/tc_gact.h>

#include <net/tc_act/tc_skbedit.h>

#include <net/tc_act/tc_skbedit.h>
@@ -363,7 +364,18 @@ static int __parse_cls_flower(struct mlx5e_priv *priv, 
			skb_flow_dissector_target(f->dissector,

			skb_flow_dissector_target(f->dissector,

						  FLOW_DISSECTOR_KEY_CONTROL,

						  FLOW_DISSECTOR_KEY_CONTROL,

						  f->key);

						  f->key);



		struct flow_dissector_key_control *mask =

			skb_flow_dissector_target(f->dissector,

						  FLOW_DISSECTOR_KEY_CONTROL,

						  f->mask);

		addr_type = key->addr_type;

		addr_type = key->addr_type;



		if (mask->flags & FLOW_DIS_IS_FRAGMENT) {

			MLX5_SET(fte_match_set_lyr_2_4, headers_c, frag, 1);

			MLX5_SET(fte_match_set_lyr_2_4, headers_v, frag,

				 key->flags & FLOW_DIS_IS_FRAGMENT);

		}

	}

	}





	if (dissector_uses_key(f->dissector, FLOW_DISSECTOR_KEY_BASIC)) {

	if (dissector_uses_key(f->dissector, FLOW_DISSECTOR_KEY_BASIC)) {

include/uapi/linux/pkt_cls.h

+7 −0
Original line number Original line Diff line number Diff line
@@ -458,11 +458,18 @@ enum { 
	TCA_FLOWER_KEY_ENC_UDP_SRC_PORT_MASK,	/* be16 */

	TCA_FLOWER_KEY_ENC_UDP_SRC_PORT_MASK,	/* be16 */

	TCA_FLOWER_KEY_ENC_UDP_DST_PORT,	/* be16 */

	TCA_FLOWER_KEY_ENC_UDP_DST_PORT,	/* be16 */

	TCA_FLOWER_KEY_ENC_UDP_DST_PORT_MASK,	/* be16 */

	TCA_FLOWER_KEY_ENC_UDP_DST_PORT_MASK,	/* be16 */



	TCA_FLOWER_KEY_FLAGS,		/* be32 */

	TCA_FLOWER_KEY_FLAGS_MASK,	/* be32 */

	__TCA_FLOWER_MAX,

	__TCA_FLOWER_MAX,

};

};





#define TCA_FLOWER_MAX (__TCA_FLOWER_MAX - 1)

#define TCA_FLOWER_MAX (__TCA_FLOWER_MAX - 1)





enum {

	TCA_FLOWER_KEY_FLAGS_IS_FRAGMENT = (1 << 0),

};



/* Match-all classifier */

/* Match-all classifier */





enum {

enum {

net/sched/cls_flower.c

+76 −0
Original line number Original line Diff line number Diff line
@@ -386,6 +386,8 @@ static const struct nla_policy fl_policy[TCA_FLOWER_MAX + 1] = { 
	[TCA_FLOWER_KEY_ENC_UDP_SRC_PORT_MASK]	= { .type = NLA_U16 },

	[TCA_FLOWER_KEY_ENC_UDP_SRC_PORT_MASK]	= { .type = NLA_U16 },

	[TCA_FLOWER_KEY_ENC_UDP_DST_PORT]	= { .type = NLA_U16 },

	[TCA_FLOWER_KEY_ENC_UDP_DST_PORT]	= { .type = NLA_U16 },

	[TCA_FLOWER_KEY_ENC_UDP_DST_PORT_MASK]	= { .type = NLA_U16 },

	[TCA_FLOWER_KEY_ENC_UDP_DST_PORT_MASK]	= { .type = NLA_U16 },

	[TCA_FLOWER_KEY_FLAGS]		= { .type = NLA_U32 },

	[TCA_FLOWER_KEY_FLAGS_MASK]	= { .type = NLA_U32 },

};

};





static void fl_set_key_val(struct nlattr **tb,

static void fl_set_key_val(struct nlattr **tb,
@@ -420,6 +422,39 @@ static void fl_set_key_vlan(struct nlattr **tb, 
	}

	}

}

}





static void fl_set_key_flag(u32 flower_key, u32 flower_mask,

			    u32 *dissector_key, u32 *dissector_mask,

			    u32 flower_flag_bit, u32 dissector_flag_bit)

{

	if (flower_mask & flower_flag_bit) {

		*dissector_mask |= dissector_flag_bit;

		if (flower_key & flower_flag_bit)

			*dissector_key |= dissector_flag_bit;

	}

}



static void fl_set_key_flags(struct nlattr **tb,

			     u32 *flags_key, u32 *flags_mask)

{

	u32 key, mask;



	if (!tb[TCA_FLOWER_KEY_FLAGS])

		return;



	key = be32_to_cpu(nla_get_u32(tb[TCA_FLOWER_KEY_FLAGS]));



	if (!tb[TCA_FLOWER_KEY_FLAGS_MASK])

		mask = ~0;

	else

		mask = be32_to_cpu(nla_get_u32(tb[TCA_FLOWER_KEY_FLAGS_MASK]));



	*flags_key  = 0;

	*flags_mask = 0;



	fl_set_key_flag(key, mask, flags_key, flags_mask,

			TCA_FLOWER_KEY_FLAGS_IS_FRAGMENT, FLOW_DIS_IS_FRAGMENT);

}



static int fl_set_key(struct net *net, struct nlattr **tb,

static int fl_set_key(struct net *net, struct nlattr **tb,

		      struct fl_flow_key *key, struct fl_flow_key *mask)

		      struct fl_flow_key *key, struct fl_flow_key *mask)

{

{
@@ -546,6 +581,8 @@ static int fl_set_key(struct net *net, struct nlattr **tb, 
		       &mask->enc_tp.dst, TCA_FLOWER_KEY_ENC_UDP_DST_PORT_MASK,

		       &mask->enc_tp.dst, TCA_FLOWER_KEY_ENC_UDP_DST_PORT_MASK,

		       sizeof(key->enc_tp.dst));

		       sizeof(key->enc_tp.dst));





	fl_set_key_flags(tb, &key->control.flags, &mask->control.flags);



	return 0;

	return 0;

}

}
@@ -880,6 +917,42 @@ static int fl_dump_key_vlan(struct sk_buff *skb, 
	return 0;

	return 0;

}

}





static void fl_get_key_flag(u32 dissector_key, u32 dissector_mask,

			    u32 *flower_key, u32 *flower_mask,

			    u32 flower_flag_bit, u32 dissector_flag_bit)

{

	if (dissector_mask & dissector_flag_bit) {

		*flower_mask |= flower_flag_bit;

		if (dissector_key & dissector_flag_bit)

			*flower_key |= flower_flag_bit;

	}

}



static int fl_dump_key_flags(struct sk_buff *skb, u32 flags_key, u32 flags_mask)

{

	u32 key, mask;

	__be32 _key, _mask;

	int err;



	if (!memchr_inv(&flags_mask, 0, sizeof(flags_mask)))

		return 0;



	key = 0;

	mask = 0;



	fl_get_key_flag(flags_key, flags_mask, &key, &mask,

			TCA_FLOWER_KEY_FLAGS_IS_FRAGMENT, FLOW_DIS_IS_FRAGMENT);



	_key = cpu_to_be32(key);

	_mask = cpu_to_be32(mask);



	err = nla_put(skb, TCA_FLOWER_KEY_FLAGS, 4, &_key);

	if (err)

		return err;



	return nla_put(skb, TCA_FLOWER_KEY_FLAGS_MASK, 4, &_mask);

}



static int fl_dump(struct net *net, struct tcf_proto *tp, unsigned long fh,

static int fl_dump(struct net *net, struct tcf_proto *tp, unsigned long fh,

		   struct sk_buff *skb, struct tcmsg *t)

		   struct sk_buff *skb, struct tcmsg *t)

{

{
@@ -1015,6 +1088,9 @@ static int fl_dump(struct net *net, struct tcf_proto *tp, unsigned long fh, 
			    sizeof(key->enc_tp.dst)))

			    sizeof(key->enc_tp.dst)))

		goto nla_put_failure;

		goto nla_put_failure;





	if (fl_dump_key_flags(skb, key->control.flags, mask->control.flags))

		goto nla_put_failure;



	nla_put_u32(skb, TCA_FLOWER_FLAGS, f->flags);

	nla_put_u32(skb, TCA_FLOWER_FLAGS, f->flags);





	if (tcf_exts_dump(skb, &f->exts))

	if (tcf_exts_dump(skb, &f->exts))