[mirror_ubuntu-focal-kernel.git] / include / net / flow_offload.h

#ifndef _NET_FLOW_OFFLOAD_H
#define _NET_FLOW_OFFLOAD_H

#include <net/flow_dissector.h>

struct flow_match {
	struct flow_dissector	*dissector;
	void			*mask;
	void			*key;
};

struct flow_match_basic {
	struct flow_dissector_key_basic *key, *mask;
};

struct flow_match_control {
	struct flow_dissector_key_control *key, *mask;
};

struct flow_match_eth_addrs {
	struct flow_dissector_key_eth_addrs *key, *mask;
};

struct flow_match_vlan {
	struct flow_dissector_key_vlan *key, *mask;
};

struct flow_match_ipv4_addrs {
	struct flow_dissector_key_ipv4_addrs *key, *mask;
};

struct flow_match_ipv6_addrs {
	struct flow_dissector_key_ipv6_addrs *key, *mask;
};

struct flow_match_ip {
	struct flow_dissector_key_ip *key, *mask;
};

struct flow_match_ports {
	struct flow_dissector_key_ports *key, *mask;
};

struct flow_match_icmp {
	struct flow_dissector_key_icmp *key, *mask;
};

struct flow_match_tcp {
	struct flow_dissector_key_tcp *key, *mask;
};

struct flow_match_mpls {
	struct flow_dissector_key_mpls *key, *mask;
};

struct flow_match_enc_keyid {
	struct flow_dissector_key_keyid *key, *mask;
};

struct flow_match_enc_opts {
	struct flow_dissector_key_enc_opts *key, *mask;
};

struct flow_rule;

void flow_rule_match_basic(const struct flow_rule *rule,
			   struct flow_match_basic *out);
void flow_rule_match_control(const struct flow_rule *rule,
			     struct flow_match_control *out);
void flow_rule_match_eth_addrs(const struct flow_rule *rule,
			       struct flow_match_eth_addrs *out);
void flow_rule_match_vlan(const struct flow_rule *rule,
			  struct flow_match_vlan *out);
void flow_rule_match_ipv4_addrs(const struct flow_rule *rule,
				struct flow_match_ipv4_addrs *out);
void flow_rule_match_ipv6_addrs(const struct flow_rule *rule,
				struct flow_match_ipv6_addrs *out);
void flow_rule_match_ip(const struct flow_rule *rule,
			struct flow_match_ip *out);
void flow_rule_match_ports(const struct flow_rule *rule,
			   struct flow_match_ports *out);
void flow_rule_match_tcp(const struct flow_rule *rule,
			 struct flow_match_tcp *out);
void flow_rule_match_icmp(const struct flow_rule *rule,
			  struct flow_match_icmp *out);
void flow_rule_match_mpls(const struct flow_rule *rule,
			  struct flow_match_mpls *out);
void flow_rule_match_enc_control(const struct flow_rule *rule,
				 struct flow_match_control *out);
void flow_rule_match_enc_ipv4_addrs(const struct flow_rule *rule,
				    struct flow_match_ipv4_addrs *out);
void flow_rule_match_enc_ipv6_addrs(const struct flow_rule *rule,
				    struct flow_match_ipv6_addrs *out);
void flow_rule_match_enc_ip(const struct flow_rule *rule,
			    struct flow_match_ip *out);
void flow_rule_match_enc_ports(const struct flow_rule *rule,
			       struct flow_match_ports *out);
void flow_rule_match_enc_keyid(const struct flow_rule *rule,
			       struct flow_match_enc_keyid *out);
void flow_rule_match_enc_opts(const struct flow_rule *rule,
			      struct flow_match_enc_opts *out);

enum flow_action_id {
	FLOW_ACTION_ACCEPT		= 0,
	FLOW_ACTION_DROP,
	FLOW_ACTION_TRAP,
	FLOW_ACTION_GOTO,
	FLOW_ACTION_REDIRECT,
	FLOW_ACTION_MIRRED,
	FLOW_ACTION_VLAN_PUSH,
	FLOW_ACTION_VLAN_POP,
	FLOW_ACTION_VLAN_MANGLE,
	FLOW_ACTION_TUNNEL_ENCAP,
	FLOW_ACTION_TUNNEL_DECAP,
	FLOW_ACTION_MANGLE,
	FLOW_ACTION_ADD,
	FLOW_ACTION_CSUM,
	FLOW_ACTION_MARK,
	FLOW_ACTION_WAKE,
	FLOW_ACTION_QUEUE,
	FLOW_ACTION_SAMPLE,
	FLOW_ACTION_POLICE,
};

/* This is mirroring enum pedit_header_type definition for easy mapping between
 * tc pedit action. Legacy TCA_PEDIT_KEY_EX_HDR_TYPE_NETWORK is mapped to
 * FLOW_ACT_MANGLE_UNSPEC, which is supported by no driver.
 */
enum flow_action_mangle_base {
	FLOW_ACT_MANGLE_UNSPEC		= 0,
	FLOW_ACT_MANGLE_HDR_TYPE_ETH,
	FLOW_ACT_MANGLE_HDR_TYPE_IP4,
	FLOW_ACT_MANGLE_HDR_TYPE_IP6,
	FLOW_ACT_MANGLE_HDR_TYPE_TCP,
	FLOW_ACT_MANGLE_HDR_TYPE_UDP,
};

struct flow_action_entry {
	enum flow_action_id		id;
	union {
		u32			chain_index;	/* FLOW_ACTION_GOTO */
		struct net_device	*dev;		/* FLOW_ACTION_REDIRECT */
		struct {				/* FLOW_ACTION_VLAN */
			u16		vid;
			__be16		proto;
			u8		prio;
		} vlan;
		struct {				/* FLOW_ACTION_PACKET_EDIT */
			enum flow_action_mangle_base htype;
			u32		offset;
			u32		mask;
			u32		val;
		} mangle;
		const struct ip_tunnel_info *tunnel;	/* FLOW_ACTION_TUNNEL_ENCAP */
		u32			csum_flags;	/* FLOW_ACTION_CSUM */
		u32			mark;		/* FLOW_ACTION_MARK */
		struct {				/* FLOW_ACTION_QUEUE */
			u32		ctx;
			u32		index;
			u8		vf;
		} queue;
		struct {				/* FLOW_ACTION_SAMPLE */
			struct psample_group	*psample_group;
			u32			rate;
			u32			trunc_size;
			bool			truncate;
		} sample;
		struct {				/* FLOW_ACTION_POLICE */
			s64			burst;
			u64			rate_bytes_ps;
		} police;
	};
};

struct flow_action {
	unsigned int			num_entries;
	struct flow_action_entry 	entries[0];
};

static inline bool flow_action_has_entries(const struct flow_action *action)
{
	return action->num_entries;
}

/**
 * flow_action_has_one_action() - check if exactly one action is present
 * @action: tc filter flow offload action
 *
 * Returns true if exactly one action is present.
 */
static inline bool flow_offload_has_one_action(const struct flow_action *action)
{
	return action->num_entries == 1;
}

#define flow_action_for_each(__i, __act, __actions)			\
        for (__i = 0, __act = &(__actions)->entries[0]; __i < (__actions)->num_entries; __act = &(__actions)->entries[++__i])

struct flow_rule {
	struct flow_match	match;
	struct flow_action	action;
};

struct flow_rule *flow_rule_alloc(unsigned int num_actions);

static inline bool flow_rule_match_key(const struct flow_rule *rule,
				       enum flow_dissector_key_id key)
{
	return dissector_uses_key(rule->match.dissector, key);
}

struct flow_stats {
	u64	pkts;
	u64	bytes;
	u64	lastused;
};

static inline void flow_stats_update(struct flow_stats *flow_stats,
				     u64 bytes, u64 pkts, u64 lastused)
{
	flow_stats->pkts	+= pkts;
	flow_stats->bytes	+= bytes;
	flow_stats->lastused	= max_t(u64, flow_stats->lastused, lastused);
}

#endif /* _NET_FLOW_OFFLOAD_H */
Commit	Line	Data
8f256622 PNA	1	#ifndef _NET_FLOW_OFFLOAD_H
	2	#define _NET_FLOW_OFFLOAD_H
	3
	4	#include <net/flow_dissector.h>
	5
	6	struct flow_match {
	7	struct flow_dissector *dissector;
	8	void *mask;
	9	void *key;
	10	};
	11
	12	struct flow_match_basic {
	13	struct flow_dissector_key_basic key, mask;
	14	};
	15
	16	struct flow_match_control {
	17	struct flow_dissector_key_control key, mask;
	18	};
	19
	20	struct flow_match_eth_addrs {
	21	struct flow_dissector_key_eth_addrs key, mask;
	22	};
	23
	24	struct flow_match_vlan {
	25	struct flow_dissector_key_vlan key, mask;
	26	};
	27
	28	struct flow_match_ipv4_addrs {
	29	struct flow_dissector_key_ipv4_addrs key, mask;
	30	};
	31
	32	struct flow_match_ipv6_addrs {
	33	struct flow_dissector_key_ipv6_addrs key, mask;
	34	};
	35
	36	struct flow_match_ip {
	37	struct flow_dissector_key_ip key, mask;
	38	};
	39
	40	struct flow_match_ports {
	41	struct flow_dissector_key_ports key, mask;
	42	};
	43
	44	struct flow_match_icmp {
	45	struct flow_dissector_key_icmp key, mask;
	46	};
	47
	48	struct flow_match_tcp {
	49	struct flow_dissector_key_tcp key, mask;
	50	};
	51
	52	struct flow_match_mpls {
	53	struct flow_dissector_key_mpls key, mask;
	54	};
	55
	56	struct flow_match_enc_keyid {
	57	struct flow_dissector_key_keyid key, mask;
	58	};
	59
	60	struct flow_match_enc_opts {
	61	struct flow_dissector_key_enc_opts key, mask;
	62	};
	63
	64	struct flow_rule;
65
66	void flow_rule_match_basic(const struct flow_rule *rule,
67	struct flow_match_basic *out);
68	void flow_rule_match_control(const struct flow_rule *rule,
69	struct flow_match_control *out);
70	void flow_rule_match_eth_addrs(const struct flow_rule *rule,
71	struct flow_match_eth_addrs *out);
72	void flow_rule_match_vlan(const struct flow_rule *rule,
73	struct flow_match_vlan *out);
74	void flow_rule_match_ipv4_addrs(const struct flow_rule *rule,
75	struct flow_match_ipv4_addrs *out);
76	void flow_rule_match_ipv6_addrs(const struct flow_rule *rule,
77	struct flow_match_ipv6_addrs *out);
78	void flow_rule_match_ip(const struct flow_rule *rule,
79	struct flow_match_ip *out);
80	void flow_rule_match_ports(const struct flow_rule *rule,
81	struct flow_match_ports *out);
82	void flow_rule_match_tcp(const struct flow_rule *rule,
83	struct flow_match_tcp *out);
84	void flow_rule_match_icmp(const struct flow_rule *rule,
85	struct flow_match_icmp *out);
86	void flow_rule_match_mpls(const struct flow_rule *rule,
87	struct flow_match_mpls *out);
88	void flow_rule_match_enc_control(const struct flow_rule *rule,
89	struct flow_match_control *out);
90	void flow_rule_match_enc_ipv4_addrs(const struct flow_rule *rule,
91	struct flow_match_ipv4_addrs *out);
92	void flow_rule_match_enc_ipv6_addrs(const struct flow_rule *rule,
93	struct flow_match_ipv6_addrs *out);
94	void flow_rule_match_enc_ip(const struct flow_rule *rule,
95	struct flow_match_ip *out);
96	void flow_rule_match_enc_ports(const struct flow_rule *rule,
97	struct flow_match_ports *out);
98	void flow_rule_match_enc_keyid(const struct flow_rule *rule,
99	struct flow_match_enc_keyid *out);
100	void flow_rule_match_enc_opts(const struct flow_rule *rule,
101	struct flow_match_enc_opts *out);
102
e3ab786b PNA	103	enum flow_action_id {
	104	FLOW_ACTION_ACCEPT = 0,
	105	FLOW_ACTION_DROP,
	106	FLOW_ACTION_TRAP,
	107	FLOW_ACTION_GOTO,
	108	FLOW_ACTION_REDIRECT,
	109	FLOW_ACTION_MIRRED,
	110	FLOW_ACTION_VLAN_PUSH,
	111	FLOW_ACTION_VLAN_POP,
	112	FLOW_ACTION_VLAN_MANGLE,
	113	FLOW_ACTION_TUNNEL_ENCAP,
	114	FLOW_ACTION_TUNNEL_DECAP,
	115	FLOW_ACTION_MANGLE,
	116	FLOW_ACTION_ADD,
	117	FLOW_ACTION_CSUM,
	118	FLOW_ACTION_MARK,
8bec2833 PNA	119	FLOW_ACTION_WAKE,
8bec2833 PNA	120	FLOW_ACTION_QUEUE,
a7a7be60	121	FLOW_ACTION_SAMPLE,
8c8cfc6e	122	FLOW_ACTION_POLICE,
e3ab786b PNA	123	};
	124
	125	/* This is mirroring enum pedit_header_type definition for easy mapping between
	126	* tc pedit action. Legacy TCA_PEDIT_KEY_EX_HDR_TYPE_NETWORK is mapped to
	127	* FLOW_ACT_MANGLE_UNSPEC, which is supported by no driver.
	128	*/
	129	enum flow_action_mangle_base {
	130	FLOW_ACT_MANGLE_UNSPEC = 0,
	131	FLOW_ACT_MANGLE_HDR_TYPE_ETH,
	132	FLOW_ACT_MANGLE_HDR_TYPE_IP4,
	133	FLOW_ACT_MANGLE_HDR_TYPE_IP6,
	134	FLOW_ACT_MANGLE_HDR_TYPE_TCP,
	135	FLOW_ACT_MANGLE_HDR_TYPE_UDP,
	136	};
	137
	138	struct flow_action_entry {
	139	enum flow_action_id id;
	140	union {
	141	u32 chain_index; /* FLOW_ACTION_GOTO */
	142	struct net_device dev; / FLOW_ACTION_REDIRECT */
	143	struct { /* FLOW_ACTION_VLAN */
	144	u16 vid;
	145	__be16 proto;
	146	u8 prio;
	147	} vlan;
	148	struct { /* FLOW_ACTION_PACKET_EDIT */
	149	enum flow_action_mangle_base htype;
	150	u32 offset;
	151	u32 mask;
	152	u32 val;
	153	} mangle;
	154	const struct ip_tunnel_info tunnel; / FLOW_ACTION_TUNNEL_ENCAP */
	155	u32 csum_flags; /* FLOW_ACTION_CSUM */
	156	u32 mark; /* FLOW_ACTION_MARK */
8bec2833 PNA	157	struct { /* FLOW_ACTION_QUEUE */
	158	u32 ctx;
	159	u32 index;
	160	u8 vf;
	161	} queue;
a7a7be60 PJV	162	struct { /* FLOW_ACTION_SAMPLE */
	163	struct psample_group *psample_group;
	164	u32 rate;
	165	u32 trunc_size;
	166	bool truncate;
	167	} sample;
8c8cfc6e PJV	168	struct { /* FLOW_ACTION_POLICE */
	169	s64 burst;
	170	u64 rate_bytes_ps;
	171	} police;
e3ab786b PNA	172	};
	173	};
	174
	175	struct flow_action {
	176	unsigned int num_entries;
	177	struct flow_action_entry entries[0];
	178	};
	179
	180	static inline bool flow_action_has_entries(const struct flow_action *action)
	181	{
	182	return action->num_entries;
	183	}
	184
ab79af32 PJV	185	/**
	186	* flow_action_has_one_action() - check if exactly one action is present
	187	* @action: tc filter flow offload action
	188	*
	189	* Returns true if exactly one action is present.
	190	*/
	191	static inline bool flow_offload_has_one_action(const struct flow_action *action)
	192	{
	193	return action->num_entries == 1;
	194	}
	195
e3ab786b	196	#define flow_action_for_each(__i, __act, __actions) \
6663cf82	197	for (__i = 0, __act = &(__actions)->entries[0]; __i < (__actions)->num_entries; __act = &(__actions)->entries[++__i])
e3ab786b	198
8f256622 PNA	199	struct flow_rule {
8f256622 PNA	200	struct flow_match match;
e3ab786b	201	struct flow_action action;
8f256622 PNA	202	};
8f256622 PNA	203
e3ab786b	204	struct flow_rule *flow_rule_alloc(unsigned int num_actions);
8f256622 PNA	205
	206	static inline bool flow_rule_match_key(const struct flow_rule *rule,
	207	enum flow_dissector_key_id key)
	208	{
	209	return dissector_uses_key(rule->match.dissector, key);
	210	}
	211
3b1903ef PNA	212	struct flow_stats {
	213	u64 pkts;
	214	u64 bytes;
	215	u64 lastused;
	216	};
	217
	218	static inline void flow_stats_update(struct flow_stats *flow_stats,
	219	u64 bytes, u64 pkts, u64 lastused)
	220	{
9f9dc493 JH	221	flow_stats->pkts += pkts;
	222	flow_stats->bytes += bytes;
	223	flow_stats->lastused = max_t(u64, flow_stats->lastused, lastused);
3b1903ef PNA	224	}
3b1903ef PNA	225
8f256622	226	#endif /* _NET_FLOW_OFFLOAD_H */