flow_offload.c | Explore in Territory

/* SPDX-License-Identifier: GPL-2.0 */
#include <linux/kernel.h>
#include <linux/slab.h>
#include <net/act_api.h>
#include <net/flow_offload.h>
#include <linux/rtnetlink.h>
#include <linux/mutex.h>
#include <linux/rhashtable.h>

struct flow_rule *flow_rule_alloc(unsigned int num_actions)
{ … }
EXPORT_SYMBOL(…);

struct flow_offload_action *offload_action_alloc(unsigned int num_actions)
{ … }

#define FLOW_DISSECTOR_MATCH(__rule, __type, __out) …	\

void flow_rule_match_meta(const struct flow_rule *rule,
			  struct flow_match_meta *out)
{ … }
EXPORT_SYMBOL(…);

void flow_rule_match_basic(const struct flow_rule *rule,
			   struct flow_match_basic *out)
{ … }
EXPORT_SYMBOL(…);

void flow_rule_match_control(const struct flow_rule *rule,
			     struct flow_match_control *out)
{ … }
EXPORT_SYMBOL(…);

void flow_rule_match_eth_addrs(const struct flow_rule *rule,
			       struct flow_match_eth_addrs *out)
{ … }
EXPORT_SYMBOL(…);

void flow_rule_match_vlan(const struct flow_rule *rule,
			  struct flow_match_vlan *out)
{ … }
EXPORT_SYMBOL(…);

void flow_rule_match_cvlan(const struct flow_rule *rule,
			   struct flow_match_vlan *out)
{ … }
EXPORT_SYMBOL(…);

void flow_rule_match_arp(const struct flow_rule *rule,
			 struct flow_match_arp *out)
{ … }
EXPORT_SYMBOL(…);

void flow_rule_match_ipv4_addrs(const struct flow_rule *rule,
				struct flow_match_ipv4_addrs *out)
{ … }
EXPORT_SYMBOL(…);

void flow_rule_match_ipv6_addrs(const struct flow_rule *rule,
				struct flow_match_ipv6_addrs *out)
{ … }
EXPORT_SYMBOL(…);

void flow_rule_match_ip(const struct flow_rule *rule,
			struct flow_match_ip *out)
{ … }
EXPORT_SYMBOL(…);

void flow_rule_match_ports(const struct flow_rule *rule,
			   struct flow_match_ports *out)
{ … }
EXPORT_SYMBOL(…);

void flow_rule_match_ports_range(const struct flow_rule *rule,
				 struct flow_match_ports_range *out)
{ … }
EXPORT_SYMBOL(…);

void flow_rule_match_tcp(const struct flow_rule *rule,
			 struct flow_match_tcp *out)
{ … }
EXPORT_SYMBOL(…);

void flow_rule_match_ipsec(const struct flow_rule *rule,
			   struct flow_match_ipsec *out)
{ … }
EXPORT_SYMBOL(…);

void flow_rule_match_icmp(const struct flow_rule *rule,
			  struct flow_match_icmp *out)
{ … }
EXPORT_SYMBOL(…);

void flow_rule_match_mpls(const struct flow_rule *rule,
			  struct flow_match_mpls *out)
{ … }
EXPORT_SYMBOL(…);

void flow_rule_match_enc_control(const struct flow_rule *rule,
				 struct flow_match_control *out)
{ … }
EXPORT_SYMBOL(…);

void flow_rule_match_enc_ipv4_addrs(const struct flow_rule *rule,
				    struct flow_match_ipv4_addrs *out)
{ … }
EXPORT_SYMBOL(…);

void flow_rule_match_enc_ipv6_addrs(const struct flow_rule *rule,
				    struct flow_match_ipv6_addrs *out)
{ … }
EXPORT_SYMBOL(…);

void flow_rule_match_enc_ip(const struct flow_rule *rule,
			    struct flow_match_ip *out)
{ … }
EXPORT_SYMBOL(…);

void flow_rule_match_enc_ports(const struct flow_rule *rule,
			       struct flow_match_ports *out)
{ … }
EXPORT_SYMBOL(…);

void flow_rule_match_enc_keyid(const struct flow_rule *rule,
			       struct flow_match_enc_keyid *out)
{ … }
EXPORT_SYMBOL(…);

void flow_rule_match_enc_opts(const struct flow_rule *rule,
			      struct flow_match_enc_opts *out)
{ … }
EXPORT_SYMBOL(…);

struct flow_action_cookie *flow_action_cookie_create(void *data,
						     unsigned int len,
						     gfp_t gfp)
{ … }
EXPORT_SYMBOL(…);

void flow_action_cookie_destroy(struct flow_action_cookie *cookie)
{ … }
EXPORT_SYMBOL(…);

void flow_rule_match_ct(const struct flow_rule *rule,
			struct flow_match_ct *out)
{ … }
EXPORT_SYMBOL(…);

void flow_rule_match_pppoe(const struct flow_rule *rule,
			   struct flow_match_pppoe *out)
{ … }
EXPORT_SYMBOL(…);

void flow_rule_match_l2tpv3(const struct flow_rule *rule,
			    struct flow_match_l2tpv3 *out)
{ … }
EXPORT_SYMBOL(…);

struct flow_block_cb *flow_block_cb_alloc(flow_setup_cb_t *cb,
					  void *cb_ident, void *cb_priv,
					  void (*release)(void *cb_priv))
{ … }
EXPORT_SYMBOL(…);

void flow_block_cb_free(struct flow_block_cb *block_cb)
{ … }
EXPORT_SYMBOL(…);

struct flow_block_cb *flow_block_cb_lookup(struct flow_block *block,
					   flow_setup_cb_t *cb, void *cb_ident)
{ … }
EXPORT_SYMBOL(…);

void *flow_block_cb_priv(struct flow_block_cb *block_cb)
{ … }
EXPORT_SYMBOL(…);

void flow_block_cb_incref(struct flow_block_cb *block_cb)
{ … }
EXPORT_SYMBOL(…);

unsigned int flow_block_cb_decref(struct flow_block_cb *block_cb)
{ … }
EXPORT_SYMBOL(…);

bool flow_block_cb_is_busy(flow_setup_cb_t *cb, void *cb_ident,
			   struct list_head *driver_block_list)
{ … }
EXPORT_SYMBOL(…);

int flow_block_cb_setup_simple(struct flow_block_offload *f,
			       struct list_head *driver_block_list,
			       flow_setup_cb_t *cb,
			       void *cb_ident, void *cb_priv,
			       bool ingress_only)
{ … }
EXPORT_SYMBOL(…);

static DEFINE_MUTEX(flow_indr_block_lock);
static LIST_HEAD(flow_block_indr_list);
static LIST_HEAD(flow_block_indr_dev_list);
static LIST_HEAD(flow_indir_dev_list);

struct flow_indr_dev { … };

static struct flow_indr_dev *flow_indr_dev_alloc(flow_indr_block_bind_cb_t *cb,
						 void *cb_priv)
{ … }

struct flow_indir_dev_info { … };

static void existing_qdiscs_register(flow_indr_block_bind_cb_t *cb, void *cb_priv)
{ … }

int flow_indr_dev_register(flow_indr_block_bind_cb_t *cb, void *cb_priv)
{ … }
EXPORT_SYMBOL(…);

static void __flow_block_indr_cleanup(void (*release)(void *cb_priv),
				      void *cb_priv,
				      struct list_head *cleanup_list)
{ … }

static void flow_block_indr_notify(struct list_head *cleanup_list)
{ … }

void flow_indr_dev_unregister(flow_indr_block_bind_cb_t *cb, void *cb_priv,
			      void (*release)(void *cb_priv))
{ … }
EXPORT_SYMBOL(…);

static void flow_block_indr_init(struct flow_block_cb *flow_block,
				 struct flow_block_offload *bo,
				 struct net_device *dev, struct Qdisc *sch, void *data,
				 void *cb_priv,
				 void (*cleanup)(struct flow_block_cb *block_cb))
{ … }

struct flow_block_cb *flow_indr_block_cb_alloc(flow_setup_cb_t *cb,
					       void *cb_ident, void *cb_priv,
					       void (*release)(void *cb_priv),
					       struct flow_block_offload *bo,
					       struct net_device *dev,
					       struct Qdisc *sch, void *data,
					       void *indr_cb_priv,
					       void (*cleanup)(struct flow_block_cb *block_cb))
{ … }
EXPORT_SYMBOL(…);

static struct flow_indir_dev_info *find_indir_dev(void *data)
{ … }

static int indir_dev_add(void *data, struct net_device *dev, struct Qdisc *sch,
			 enum tc_setup_type type, void (*cleanup)(struct flow_block_cb *block_cb),
			 struct flow_block_offload *bo)
{ … }

static int indir_dev_remove(void *data)
{ … }

int flow_indr_dev_setup_offload(struct net_device *dev,	struct Qdisc *sch,
				enum tc_setup_type type, void *data,
				struct flow_block_offload *bo,
				void (*cleanup)(struct flow_block_cb *block_cb))
{ … }
EXPORT_SYMBOL(…);

bool flow_indr_dev_exists(void)
{ … }
EXPORT_SYMBOL(…);
linux/net/core/flow_offload.c
