include/net/flow_offload.h - third_party/kernel - Git at Google

 #ifndef _NET_FLOW_OFFLOAD_H
 #define _NET_FLOW_OFFLOAD_H

 #include <linux/kernel.h>
 #include <linux/list.h>
 #include <net/flow_dissector.h>
 #include <linux/rhashtable.h>

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

 struct flow_match_meta {
 	struct flow_dissector_key_meta *key, *mask;
 };

 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_meta(const struct flow_rule *rule,
 			  struct flow_match_meta *out);
 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_cvlan(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_REDIRECT_INGRESS,
 	FLOW_ACTION_MIRRED_INGRESS,
 	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_PTYPE,
 	FLOW_ACTION_WAKE,
 	FLOW_ACTION_QUEUE,
 	FLOW_ACTION_SAMPLE,
 	FLOW_ACTION_POLICE,
 	FLOW_ACTION_CT,
 	FLOW_ACTION_MPLS_PUSH,
 	FLOW_ACTION_MPLS_POP,
 	FLOW_ACTION_MPLS_MANGLE,
 	NUM_FLOW_ACTIONS,
 };

 /* 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,
 };

 typedef void (*action_destr)(void *priv);

 struct flow_action_entry {
 	enum flow_action_id		id;
 	action_destr			destructor;
 	void				*destructor_priv;
 	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;
 		struct ip_tunnel_info	*tunnel;	/* FLOW_ACTION_TUNNEL_ENCAP */
 		u32			csum_flags;	/* FLOW_ACTION_CSUM */
 		u32			mark;		/* FLOW_ACTION_MARK */
 		u16                     ptype;          /* FLOW_ACTION_PTYPE */
 		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_CT */
 			int action;
 			u16 zone;
 		} ct;
 		struct {				/* FLOW_ACTION_MPLS_PUSH */
 			u32		label;
 			__be16		proto;
 			u8		tc;
 			u8		bos;
 			u8		ttl;
 		} mpls_push;
 		struct {				/* FLOW_ACTION_MPLS_POP */
 			__be16		proto;
 		} mpls_pop;
 		struct {				/* FLOW_ACTION_MPLS_MANGLE */
 			u32		label;
 			u8		tc;
 			u8		bos;
 			u8		ttl;
 		} mpls_mangle;
 	};
 };

 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);
 }

 enum flow_block_command {
 	FLOW_BLOCK_BIND,
 	FLOW_BLOCK_UNBIND,
 };

 enum flow_block_binder_type {
 	FLOW_BLOCK_BINDER_TYPE_UNSPEC,
 	FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS,
 	FLOW_BLOCK_BINDER_TYPE_CLSACT_EGRESS,
 };

 struct flow_block {
 	struct list_head cb_list;
 };

 struct netlink_ext_ack;

 struct flow_block_offload {
 	enum flow_block_command command;
 	enum flow_block_binder_type binder_type;
 	bool block_shared;
 	bool unlocked_driver_cb;
 	struct net *net;
 	struct flow_block *block;
 	struct list_head cb_list;
 	struct list_head *driver_block_list;
 	struct netlink_ext_ack *extack;
 };

 enum tc_setup_type;
 typedef int flow_setup_cb_t(enum tc_setup_type type, void *type_data,
 			    void *cb_priv);

 struct flow_block_cb {
 	struct list_head	driver_list;
 	struct list_head	list;
 	flow_setup_cb_t		*cb;
 	void			*cb_ident;
 	void			*cb_priv;
 	void			(*release)(void *cb_priv);
 	unsigned int		refcnt;
 };

 struct flow_block_cb *flow_block_cb_alloc(flow_setup_cb_t *cb,
 					  void *cb_ident, void *cb_priv,
 					  void (*release)(void *cb_priv));
 void flow_block_cb_free(struct flow_block_cb *block_cb);

 struct flow_block_cb *flow_block_cb_lookup(struct flow_block *block,
 					   flow_setup_cb_t *cb, void *cb_ident);

 void *flow_block_cb_priv(struct flow_block_cb *block_cb);
 void flow_block_cb_incref(struct flow_block_cb *block_cb);
 unsigned int flow_block_cb_decref(struct flow_block_cb *block_cb);

 static inline void flow_block_cb_add(struct flow_block_cb *block_cb,
 				     struct flow_block_offload *offload)
 {
 	list_add_tail(&block_cb->list, &offload->cb_list);
 }

 static inline void flow_block_cb_remove(struct flow_block_cb *block_cb,
 					struct flow_block_offload *offload)
 {
 	list_move(&block_cb->list, &offload->cb_list);
 }

 bool flow_block_cb_is_busy(flow_setup_cb_t *cb, void *cb_ident,
 			   struct list_head *driver_block_list);

 int flow_block_cb_setup_simple(struct flow_block_offload *f,
 			       struct list_head *driver_list,
 			       flow_setup_cb_t *cb,
 			       void *cb_ident, void *cb_priv, bool ingress_only);

 enum flow_cls_command {
 	FLOW_CLS_REPLACE,
 	FLOW_CLS_DESTROY,
 	FLOW_CLS_STATS,
 	FLOW_CLS_TMPLT_CREATE,
 	FLOW_CLS_TMPLT_DESTROY,
 };

 struct flow_cls_common_offload {
 	u32 chain_index;
 	__be16 protocol;
 	u32 prio;
 	struct netlink_ext_ack *extack;
 };

 struct flow_cls_offload {
 	struct flow_cls_common_offload common;
 	enum flow_cls_command command;
 	unsigned long cookie;
 	struct flow_rule *rule;
 	struct flow_stats stats;
 	u32 classid;
 };

 static inline struct flow_rule *
 flow_cls_offload_flow_rule(struct flow_cls_offload *flow_cmd)
 {
 	return flow_cmd->rule;
 }

 static inline void flow_block_init(struct flow_block *flow_block)
 {
 	INIT_LIST_HEAD(&flow_block->cb_list);
 }

 typedef int flow_indr_block_bind_cb_t(struct net_device *dev, void *cb_priv,
 				      enum tc_setup_type type, void *type_data);

 typedef void flow_indr_block_cmd_t(struct net_device *dev,
 				   flow_indr_block_bind_cb_t *cb, void *cb_priv,
 				   enum flow_block_command command);

 struct flow_indr_block_entry {
 	flow_indr_block_cmd_t *cb;
 	struct list_head	list;
 };

 void flow_indr_add_block_cb(struct flow_indr_block_entry *entry);

 void flow_indr_del_block_cb(struct flow_indr_block_entry *entry);

 int __flow_indr_block_cb_register(struct net_device *dev, void *cb_priv,
 				  flow_indr_block_bind_cb_t *cb,
 				  void *cb_ident);

 void __flow_indr_block_cb_unregister(struct net_device *dev,
 				     flow_indr_block_bind_cb_t *cb,
 				     void *cb_ident);

 int flow_indr_block_cb_register(struct net_device *dev, void *cb_priv,
 				flow_indr_block_bind_cb_t *cb, void *cb_ident);

 void flow_indr_block_cb_unregister(struct net_device *dev,
 				   flow_indr_block_bind_cb_t *cb,
 				   void *cb_ident);

 void flow_indr_block_call(struct net_device *dev,
 			  struct flow_block_offload *bo,
 			  enum flow_block_command command);

 #endif /* _NET_FLOW_OFFLOAD_H */
	#ifndef _NET_FLOW_OFFLOAD_H
	#define _NET_FLOW_OFFLOAD_H

	#include <linux/kernel.h>
	#include <linux/list.h>
	#include <net/flow_dissector.h>
	#include <linux/rhashtable.h>

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

	struct flow_match_meta {
	struct flow_dissector_key_meta key, mask;
	};

	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_meta(const struct flow_rule *rule,
	struct flow_match_meta *out);
	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_cvlan(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_REDIRECT_INGRESS,
	FLOW_ACTION_MIRRED_INGRESS,
	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_PTYPE,
	FLOW_ACTION_WAKE,
	FLOW_ACTION_QUEUE,
	FLOW_ACTION_SAMPLE,
	FLOW_ACTION_POLICE,
	FLOW_ACTION_CT,
	FLOW_ACTION_MPLS_PUSH,
	FLOW_ACTION_MPLS_POP,
	FLOW_ACTION_MPLS_MANGLE,
	NUM_FLOW_ACTIONS,
	};

	/* 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,
	};

	typedef void (action_destr)(void priv);

	struct flow_action_entry {
	enum flow_action_id id;
	action_destr destructor;
	void *destructor_priv;
	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;
	struct ip_tunnel_info tunnel; / FLOW_ACTION_TUNNEL_ENCAP */
	u32 csum_flags; /* FLOW_ACTION_CSUM */
	u32 mark; /* FLOW_ACTION_MARK */
	u16 ptype; /* FLOW_ACTION_PTYPE */
	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_CT */
	int action;
	u16 zone;
	} ct;
	struct { /* FLOW_ACTION_MPLS_PUSH */
	u32 label;
	__be16 proto;
	u8 tc;
	u8 bos;
	u8 ttl;
	} mpls_push;
	struct { /* FLOW_ACTION_MPLS_POP */
	__be16 proto;
	} mpls_pop;
	struct { /* FLOW_ACTION_MPLS_MANGLE */
	u32 label;
	u8 tc;
	u8 bos;
	u8 ttl;
	} mpls_mangle;
	};
	};

	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);
	}

	enum flow_block_command {
	FLOW_BLOCK_BIND,
	FLOW_BLOCK_UNBIND,
	};

	enum flow_block_binder_type {
	FLOW_BLOCK_BINDER_TYPE_UNSPEC,
	FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS,
	FLOW_BLOCK_BINDER_TYPE_CLSACT_EGRESS,
	};

	struct flow_block {
	struct list_head cb_list;
	};

	struct netlink_ext_ack;

	struct flow_block_offload {
	enum flow_block_command command;
	enum flow_block_binder_type binder_type;
	bool block_shared;
	bool unlocked_driver_cb;
	struct net *net;
	struct flow_block *block;
	struct list_head cb_list;
	struct list_head *driver_block_list;
	struct netlink_ext_ack *extack;
	};

	enum tc_setup_type;
	typedef int flow_setup_cb_t(enum tc_setup_type type, void *type_data,
	void *cb_priv);

	struct flow_block_cb {
	struct list_head driver_list;
	struct list_head list;
	flow_setup_cb_t *cb;
	void *cb_ident;
	void *cb_priv;
	void (release)(void cb_priv);
	unsigned int refcnt;
	};

	struct flow_block_cb flow_block_cb_alloc(flow_setup_cb_t cb,
	void cb_ident, void cb_priv,
	void (release)(void cb_priv));
	void flow_block_cb_free(struct flow_block_cb *block_cb);

	struct flow_block_cb flow_block_cb_lookup(struct flow_block block,
	flow_setup_cb_t cb, void cb_ident);

	void flow_block_cb_priv(struct flow_block_cb block_cb);
	void flow_block_cb_incref(struct flow_block_cb *block_cb);
	unsigned int flow_block_cb_decref(struct flow_block_cb *block_cb);

	static inline void flow_block_cb_add(struct flow_block_cb *block_cb,
	struct flow_block_offload *offload)
	{
	list_add_tail(&block_cb->list, &offload->cb_list);
	}

	static inline void flow_block_cb_remove(struct flow_block_cb *block_cb,
	struct flow_block_offload *offload)
	{
	list_move(&block_cb->list, &offload->cb_list);
	}

	bool flow_block_cb_is_busy(flow_setup_cb_t cb, void cb_ident,
	struct list_head *driver_block_list);

	int flow_block_cb_setup_simple(struct flow_block_offload *f,
	struct list_head *driver_list,
	flow_setup_cb_t *cb,
	void cb_ident, void cb_priv, bool ingress_only);

	enum flow_cls_command {
	FLOW_CLS_REPLACE,
	FLOW_CLS_DESTROY,
	FLOW_CLS_STATS,
	FLOW_CLS_TMPLT_CREATE,
	FLOW_CLS_TMPLT_DESTROY,
	};

	struct flow_cls_common_offload {
	u32 chain_index;
	__be16 protocol;
	u32 prio;
	struct netlink_ext_ack *extack;
	};

	struct flow_cls_offload {
	struct flow_cls_common_offload common;
	enum flow_cls_command command;
	unsigned long cookie;
	struct flow_rule *rule;
	struct flow_stats stats;
	u32 classid;
	};

	static inline struct flow_rule *
	flow_cls_offload_flow_rule(struct flow_cls_offload *flow_cmd)
	{
	return flow_cmd->rule;
	}

	static inline void flow_block_init(struct flow_block *flow_block)
	{
	INIT_LIST_HEAD(&flow_block->cb_list);
	}

	typedef int flow_indr_block_bind_cb_t(struct net_device dev, void cb_priv,
	enum tc_setup_type type, void *type_data);

	typedef void flow_indr_block_cmd_t(struct net_device *dev,
	flow_indr_block_bind_cb_t cb, void cb_priv,
	enum flow_block_command command);

	struct flow_indr_block_entry {
	flow_indr_block_cmd_t *cb;
	struct list_head list;
	};

	void flow_indr_add_block_cb(struct flow_indr_block_entry *entry);

	void flow_indr_del_block_cb(struct flow_indr_block_entry *entry);

	int __flow_indr_block_cb_register(struct net_device dev, void cb_priv,
	flow_indr_block_bind_cb_t *cb,
	void *cb_ident);

	void __flow_indr_block_cb_unregister(struct net_device *dev,
	flow_indr_block_bind_cb_t *cb,
	void *cb_ident);

	int flow_indr_block_cb_register(struct net_device dev, void cb_priv,
	flow_indr_block_bind_cb_t cb, void cb_ident);

	void flow_indr_block_cb_unregister(struct net_device *dev,
	flow_indr_block_bind_cb_t *cb,
	void *cb_ident);

	void flow_indr_block_call(struct net_device *dev,
	struct flow_block_offload *bo,
	enum flow_block_command command);

	#endif /* _NET_FLOW_OFFLOAD_H */