[ovs.git] / ofproto / ofproto-dpif.h

/* Copyright (c) 2009-2017 Nicira, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License. */

#ifndef OFPROTO_DPIF_H
#define OFPROTO_DPIF_H 1

/* ofproto-dpif -- DPIF based ofproto implementation.
 *
 * ofproto-dpif provides an ofproto implementation for those platforms which
 * implement the netdev and dpif interface defined in netdev.h and dpif.h.  The
 * most important of which is the Linux Kernel Module (dpif-netlink), but
 * alternatives are supported such as a userspace only implementation
 * (dpif-netdev), and a dummy implementation used for unit testing.
 *
 * ofproto-dpif is divided into three major chunks.
 *
 * - ofproto-dpif.c
 *   The main ofproto-dpif module is responsible for implementing the
 *   provider interface, installing and removing datapath flows, maintaining
 *   packet statistics, running protocols (BFD, LACP, STP, etc), and
 *   configuring relevant submodules.
 *
 * - ofproto-dpif-upcall.c
 *   ofproto-dpif-upcall is responsible for retrieving upcalls from the kernel,
 *   processing miss upcalls, and handing more complex ones up to the main
 *   ofproto-dpif module.  Miss upcall processing boils down to figuring out
 *   what each packet's actions are, executing them (i.e. asking the kernel to
 *   forward it), and handing it up to ofproto-dpif to decided whether or not
 *   to install a kernel flow.
 *
 * - ofproto-dpif-xlate.c
 *   ofproto-dpif-xlate is responsible for translating OpenFlow actions into
 *   datapath actions.
 */

#include <stdint.h>

#include "dpif.h"
#include "fail-open.h"
#include "hmapx.h"
#include "odp-util.h"
#include "id-pool.h"
#include "ovs-thread.h"
#include "ofproto-provider.h"
#include "util.h"
#include "ovs-thread.h"

struct dpif_flow_stats;
struct ofproto_async_msg;
struct ofproto_dpif;
struct uuid;
struct xlate_cache;
struct xlate_ctx;

/* Number of implemented OpenFlow tables. */
enum { N_TABLES = 255 };
enum { TBL_INTERNAL = N_TABLES - 1 };    /* Used for internal hidden rules. */
BUILD_ASSERT_DECL(N_TABLES >= 2 && N_TABLES <= 255);

struct rule_dpif {
    struct rule up;

    /* These statistics:
     *
     *   - Do include packets and bytes from datapath flows which have not
     *   recently been processed by a revalidator. */
    struct ovs_mutex stats_mutex;
    struct dpif_flow_stats stats OVS_GUARDED;

   /* In non-NULL, will point to a new rule (for which a reference is held) to
    * which all the stats updates should be forwarded. This exists only
    * transitionally when flows are replaced.
    *
    * Protected by stats_mutex.  If both 'rule->stats_mutex' and
    * 'rule->new_rule->stats_mutex' must be held together, acquire them in that
    * order, */
    struct rule_dpif *new_rule OVS_GUARDED;
    bool forward_counts OVS_GUARDED;   /* Forward counts? 'used' time will be
                                        * forwarded in all cases. */

    /* If non-zero then the recirculation id that has
     * been allocated for use with this rule.
     * The recirculation id and associated internal flow should
     * be freed when the rule is freed */
    uint32_t recirc_id;
};

struct rule_dpif *rule_dpif_lookup_from_table(struct ofproto_dpif *,
                                              ovs_version_t, struct flow *,
                                              struct flow_wildcards *,
                                              const struct dpif_flow_stats *,
                                              uint8_t *table_id,
                                              ofp_port_t in_port,
                                              bool may_packet_in,
                                              bool honor_table_miss,
                                              struct xlate_cache *);

void rule_dpif_credit_stats(struct rule_dpif *,
                            const struct dpif_flow_stats *);

void rule_set_recirc_id(struct rule *, uint32_t id);

/* Returns true if 'rule' is an internal rule, false otherwise. */
static inline bool
rule_dpif_is_internal(const struct rule_dpif *rule)
{
    return rule->up.table_id == TBL_INTERNAL;
}
\f
/* Groups. */

enum group_selection_method {
    SEL_METHOD_DEFAULT,
    SEL_METHOD_DP_HASH,
    SEL_METHOD_HASH,
};

struct group_dpif {
    struct ofgroup up;

    /* These statistics:
     *
     *   - Do include packets and bytes from datapath flows which have not
     *   recently been processed by a revalidator. */
    struct ovs_mutex stats_mutex;
    uint64_t packet_count OVS_GUARDED;  /* Number of packets received. */
    uint64_t byte_count OVS_GUARDED;    /* Number of bytes received. */

    enum group_selection_method selection_method;
    enum ovs_hash_alg hash_alg;         /* dp_hash algorithm to be applied. */
    uint32_t hash_basis;                /* Basis for dp_hash. */
    uint32_t hash_mask;                 /* Used to mask dp_hash (2^N - 1).*/
    struct ofputil_bucket **hash_map;   /* Map hash values to buckets. */
};

void group_dpif_credit_stats(struct group_dpif *,
                             struct ofputil_bucket *,
                             const struct dpif_flow_stats *);
struct group_dpif *group_dpif_lookup(struct ofproto_dpif *,
                                     uint32_t group_id, ovs_version_t version,
                                     bool take_ref);

\f
/* Backers.
 *
 * A "backer" is the datapath (dpif) on which an dpif-based bridge (an
 * ofproto-dpif) resides.  A backer can host several bridges, but a bridge is
 * backed by only a single dpif. */


/* DPIF_SUPPORT_FIELD(TYPE, FIELD_NAME, FIELD_DESCRIPTION)
 *
 * Each 'DPIF_SUPPORT_FIELD' defines a member in 'struct dpif_backer_support'
 * and represents support for a datapath action.
 * They are defined as macros to keep 'dpif_show_support()' in sync
 * as new fields are added.  */
#define DPIF_SUPPORT_FIELDS                                                 \
    /* True if the datapath supports masked data in OVS_ACTION_ATTR_SET     \
     * actions. */                                                          \
    DPIF_SUPPORT_FIELD(bool, masked_set_action, "Masked set action")        \
                                                                            \
    /* True if the datapath supports tnl_push and pop actions. */           \
    DPIF_SUPPORT_FIELD(bool, tnl_push_pop, "Tunnel push pop")               \
                                                                            \
    /* True if the datapath supports OVS_FLOW_ATTR_UFID. */                 \
    DPIF_SUPPORT_FIELD(bool, ufid, "Ufid")                                  \
                                                                            \
    /* True if the datapath supports OVS_ACTION_ATTR_TRUNC action. */       \
    DPIF_SUPPORT_FIELD(bool, trunc, "Truncate action")                      \
                                                                            \
    /* True if the datapath supports OVS_ACTION_ATTR_CLONE action. */       \
    DPIF_SUPPORT_FIELD(bool, clone, "Clone action")                         \
                                                                            \
    /* Maximum level of nesting allowed by OVS_ACTION_ATTR_SAMPLE action. */\
    DPIF_SUPPORT_FIELD(size_t, sample_nesting, "Sample nesting")            \
                                                                            \
    /* OVS_CT_ATTR_EVENTMASK supported by OVS_ACTION_ATTR_CT action. */     \
    DPIF_SUPPORT_FIELD(bool, ct_eventmask, "Conntrack eventmask")           \
                                                                            \
    /* True if the datapath supports OVS_ACTION_ATTR_CT_CLEAR action. */    \
    DPIF_SUPPORT_FIELD(bool, ct_clear, "Conntrack clear")                   \
                                                                            \
    /* Highest supported dp_hash algorithm. */                              \
    DPIF_SUPPORT_FIELD(size_t, max_hash_alg, "Max dp_hash algorithm")

/* Stores the various features which the corresponding backer supports. */
struct dpif_backer_support {
#define DPIF_SUPPORT_FIELD(TYPE, NAME, TITLE) TYPE NAME;
    DPIF_SUPPORT_FIELDS
#undef DPIF_SUPPORT_FIELD

    /* Each member represents support for related OVS_KEY_ATTR_* fields. */
    struct odp_support odp;
};

/* Reasons that we might need to revalidate every datapath flow, and
 * corresponding coverage counters.
 *
 * A value of 0 means that there is no need to revalidate.
 *
 * It would be nice to have some cleaner way to integrate with coverage
 * counters, but with only a few reasons I guess this is good enough for
 * now. */
enum revalidate_reason {
    REV_RECONFIGURE = 1,       /* Switch configuration changed. */
    REV_STP,                   /* Spanning tree protocol port status change. */
    REV_RSTP,                  /* RSTP port status change. */
    REV_BOND,                  /* Bonding changed. */
    REV_PORT_TOGGLED,          /* Port enabled or disabled by CFM, LACP, ...*/
    REV_FLOW_TABLE,            /* Flow table changed. */
    REV_MAC_LEARNING,          /* Mac learning changed. */
    REV_MCAST_SNOOPING,        /* Multicast snooping changed. */
};

/* All datapaths of a given type share a single dpif backer instance. */
struct dpif_backer {
    char *type;
    int refcount;
    struct dpif *dpif;
    struct udpif *udpif;

    struct ovs_rwlock odp_to_ofport_lock;
    struct hmap odp_to_ofport_map OVS_GUARDED; /* Contains "struct ofport"s. */

    struct simap tnl_backers;      /* Set of dpif ports backing tunnels. */

    enum revalidate_reason need_revalidate; /* Revalidate all flows. */

    bool recv_set_enable; /* Enables or disables receiving packets. */

    /* Meter. */
    struct id_pool *meter_ids;     /* Datapath meter allocation. */

    /* Version string of the datapath stored in OVSDB. */
    char *dp_version_string;

    /* Datapath feature support. */
    struct dpif_backer_support bt_support;   /* Boot time support. Set once
                                                when vswitch starts up, then
                                                it is read only through out
                                                the life time of vswitchd. */
    struct dpif_backer_support rt_support;   /* Runtime support. Can be
                                                set to a lower level in
                                                feature than 'bt_support'. */

    struct atomic_count tnl_count;
};

/* All existing ofproto_backer instances, indexed by ofproto->up.type. */
extern struct shash all_dpif_backers;

struct ofport_dpif *odp_port_to_ofport(const struct dpif_backer *, odp_port_t);
\f
/* A bridge based on a "dpif" datapath. */

struct ofproto_dpif {
    /* In 'all_ofproto_dpifs_by_name'. */
    struct hmap_node all_ofproto_dpifs_by_name_node;

    /* In 'all_ofproto_dpifs_by_uuid'. */
    struct hmap_node all_ofproto_dpifs_by_uuid_node;

    struct ofproto up;
    struct dpif_backer *backer;

    /* Unique identifier for this instantiation of this bridge in this running
     * process.  */
    struct uuid uuid;

    ATOMIC(ovs_version_t) tables_version;  /* For classifier lookups. */

    uint64_t dump_seq; /* Last read of udpif_dump_seq(). */

    /* Special OpenFlow rules. */
    struct rule_dpif *miss_rule; /* Sends flow table misses to controller. */
    struct rule_dpif *no_packet_in_rule; /* Drops flow table misses. */
    struct rule_dpif *drop_frags_rule; /* Used in OFPUTIL_FRAG_DROP mode. */

    /* Bridging. */
    struct netflow *netflow;
    struct dpif_sflow *sflow;
    struct dpif_ipfix *ipfix;
    struct hmap bundles;        /* Contains "struct ofbundle"s. */
    struct mac_learning *ml;
    struct mcast_snooping *ms;
    bool has_bonded_bundles;
    bool lacp_enabled;
    struct mbridge *mbridge;

    struct ovs_mutex stats_mutex;
    struct netdev_stats stats OVS_GUARDED; /* To account packets generated and
                                            * consumed in userspace. */

    /* Spanning tree. */
    struct stp *stp;
    long long int stp_last_tick;

    /* Rapid Spanning Tree. */
    struct rstp *rstp;
    long long int rstp_last_tick;

    /* Ports. */
    struct sset ports;             /* Set of standard port names. */
    struct sset ghost_ports;       /* Ports with no datapath port. */
    struct sset port_poll_set;     /* Queued names for port_poll() reply. */
    int port_poll_errno;           /* Last errno for port_poll() reply. */
    uint64_t change_seq;           /* Connectivity status changes. */

    /* Work queues. */
    struct guarded_list ams;      /* Contains "struct ofproto_async_msgs"s. */
    struct seq *ams_seq;          /* For notifying 'ams' reception. */
    uint64_t ams_seqno;
};

struct ofproto_dpif *ofproto_dpif_lookup_by_name(const char *name);
struct ofproto_dpif *ofproto_dpif_lookup_by_uuid(const struct uuid *uuid);

ovs_version_t ofproto_dpif_get_tables_version(struct ofproto_dpif *);

void ofproto_dpif_credit_table_stats(struct ofproto_dpif *, uint8_t table_id,
                                     uint64_t n_matches, uint64_t n_misses);

int ofproto_dpif_execute_actions(struct ofproto_dpif *, ovs_version_t,
                                 const struct flow *, struct rule_dpif *,
                                 const struct ofpact *, size_t ofpacts_len,
                                 struct dp_packet *);
int ofproto_dpif_execute_actions__(struct ofproto_dpif *, ovs_version_t,
                                   const struct flow *, struct rule_dpif *,
                                   const struct ofpact *, size_t ofpacts_len,
                                   int depth, int resubmits,
                                   struct dp_packet *);
void ofproto_dpif_send_async_msg(struct ofproto_dpif *,
                                 struct ofproto_async_msg *);
int ofproto_dpif_send_packet(const struct ofport_dpif *, bool oam,
                             struct dp_packet *);
enum ofperr ofproto_dpif_flow_mod_init_for_learn(
    struct ofproto_dpif *, const struct ofputil_flow_mod *,
    struct ofproto_flow_mod *);

struct ofport_dpif *ofp_port_to_ofport(const struct ofproto_dpif *,
                                       ofp_port_t);

int ofproto_dpif_add_internal_flow(struct ofproto_dpif *,
                                   struct match *, int priority,
                                   uint16_t idle_timeout,
                                   const struct ofpbuf *ofpacts,
                                   struct rule **rulep);
int ofproto_dpif_delete_internal_flow(struct ofproto_dpif *, struct match *,
                                      int priority);

bool ovs_native_tunneling_is_on(struct ofproto_dpif *);

#endif /* ofproto-dpif.h */
Commit	Line	Data
535e3acf	1	/* Copyright (c) 2009-2017 Nicira, Inc.
9583bc14 EJ	2	*
	3	* Licensed under the Apache License, Version 2.0 (the "License");
	4	* you may not use this file except in compliance with the License.
	5	* You may obtain a copy of the License at:
	6	*
	7	* http://www.apache.org/licenses/LICENSE-2.0
	8	*
	9	* Unless required by applicable law or agreed to in writing, software
	10	* distributed under the License is distributed on an "AS IS" BASIS,
	11	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	12	* See the License for the specific language governing permissions and
	13	* limitations under the License. */
	14
	15	#ifndef OFPROTO_DPIF_H
	16	#define OFPROTO_DPIF_H 1
	17
07a3cd5c	18	/* ofproto-dpif -- DPIF based ofproto implementation.
e1ec7dd4	19	*
07a3cd5c	20	* ofproto-dpif provides an ofproto implementation for those platforms which
e1ec7dd4	21	* implement the netdev and dpif interface defined in netdev.h and dpif.h. The
1139c77d	22	* most important of which is the Linux Kernel Module (dpif-netlink), but
e1ec7dd4 EJ	23	* alternatives are supported such as a userspace only implementation
	24	* (dpif-netdev), and a dummy implementation used for unit testing.
	25	*
07a3cd5c	26	* ofproto-dpif is divided into three major chunks.
e1ec7dd4 EJ	27	*
	28	* - ofproto-dpif.c
	29	* The main ofproto-dpif module is responsible for implementing the
	30	* provider interface, installing and removing datapath flows, maintaining
	31	* packet statistics, running protocols (BFD, LACP, STP, etc), and
	32	* configuring relevant submodules.
	33	*
	34	* - ofproto-dpif-upcall.c
07a3cd5c	35	* ofproto-dpif-upcall is responsible for retrieving upcalls from the kernel,
e1ec7dd4 EJ	36	* processing miss upcalls, and handing more complex ones up to the main
	37	* ofproto-dpif module. Miss upcall processing boils down to figuring out
	38	* what each packet's actions are, executing them (i.e. asking the kernel to
	39	* forward it), and handing it up to ofproto-dpif to decided whether or not
	40	* to install a kernel flow.
	41	*
	42	* - ofproto-dpif-xlate.c
07a3cd5c BP	43	* ofproto-dpif-xlate is responsible for translating OpenFlow actions into
	44	* datapath actions.
	45	*/
	46
	47	#include <stdint.h>
	48
	49	#include "dpif.h"
	50	#include "fail-open.h"
	51	#include "hmapx.h"
	52	#include "odp-util.h"
333ad77d	53	#include "id-pool.h"
07a3cd5c BP	54	#include "ovs-thread.h"
	55	#include "ofproto-provider.h"
	56	#include "util.h"
	57	#include "ovs-thread.h"
	58
	59	struct dpif_flow_stats;
	60	struct ofproto_async_msg;
	61	struct ofproto_dpif;
911b4a7e	62	struct uuid;
07a3cd5c	63	struct xlate_cache;
06db81cc	64	struct xlate_ctx;
07a3cd5c BP	65
	66	/* Number of implemented OpenFlow tables. */
	67	enum { N_TABLES = 255 };
	68	enum { TBL_INTERNAL = N_TABLES - 1 }; /* Used for internal hidden rules. */
	69	BUILD_ASSERT_DECL(N_TABLES >= 2 && N_TABLES <= 255);
	70
	71	struct rule_dpif {
	72	struct rule up;
	73
	74	/* These statistics:
	75	*
	76	* - Do include packets and bytes from datapath flows which have not
	77	* recently been processed by a revalidator. */
	78	struct ovs_mutex stats_mutex;
	79	struct dpif_flow_stats stats OVS_GUARDED;
	80
	81	/* In non-NULL, will point to a new rule (for which a reference is held) to
	82	* which all the stats updates should be forwarded. This exists only
	83	* transitionally when flows are replaced.
	84	*
	85	* Protected by stats_mutex. If both 'rule->stats_mutex' and
	86	* 'rule->new_rule->stats_mutex' must be held together, acquire them in that
	87	* order, */
	88	struct rule_dpif *new_rule OVS_GUARDED;
	89	bool forward_counts OVS_GUARDED; /* Forward counts? 'used' time will be
	90	* forwarded in all cases. */
	91
	92	/* If non-zero then the recirculation id that has
	93	* been allocated for use with this rule.
	94	* The recirculation id and associated internal flow should
	95	* be freed when the rule is freed */
	96	uint32_t recirc_id;
	97	};
	98
	99	struct rule_dpif rule_dpif_lookup_from_table(struct ofproto_dpif ,
	100	ovs_version_t, struct flow *,
	101	struct flow_wildcards *,
	102	const struct dpif_flow_stats *,
	103	uint8_t *table_id,
	104	ofp_port_t in_port,
	105	bool may_packet_in,
	106	bool honor_table_miss,
	107	struct xlate_cache *);
	108
	109	void rule_dpif_credit_stats(struct rule_dpif *,
	110	const struct dpif_flow_stats *);
	111
	112	void rule_set_recirc_id(struct rule *, uint32_t id);
	113
	114	/* Returns true if 'rule' is an internal rule, false otherwise. */
	115	static inline bool
	116	rule_dpif_is_internal(const struct rule_dpif *rule)
	117	{
	118	return rule->up.table_id == TBL_INTERNAL;
	119	}
	120	\f
	121	/* Groups. */
	122
2e3fd24c JS	123	enum group_selection_method {
	124	SEL_METHOD_DEFAULT,
	125	SEL_METHOD_DP_HASH,
	126	SEL_METHOD_HASH,
	127	};
	128
07a3cd5c BP	129	struct group_dpif {
	130	struct ofgroup up;
	131
	132	/* These statistics:
	133	*
	134	* - Do include packets and bytes from datapath flows which have not
	135	* recently been processed by a revalidator. */
	136	struct ovs_mutex stats_mutex;
	137	uint64_t packet_count OVS_GUARDED; /* Number of packets received. */
	138	uint64_t byte_count OVS_GUARDED; /* Number of bytes received. */
2e3fd24c JS	139
	140	enum group_selection_method selection_method;
	141	enum ovs_hash_alg hash_alg; /* dp_hash algorithm to be applied. */
	142	uint32_t hash_basis; /* Basis for dp_hash. */
	143	uint32_t hash_mask; /* Used to mask dp_hash (2^N - 1).*/
	144	struct ofputil_bucket *hash_map; / Map hash values to buckets. */
07a3cd5c BP	145	};
	146
	147	void group_dpif_credit_stats(struct group_dpif *,
	148	struct ofputil_bucket *,
	149	const struct dpif_flow_stats *);
	150	struct group_dpif group_dpif_lookup(struct ofproto_dpif ,
	151	uint32_t group_id, ovs_version_t version,
	152	bool take_ref);
2e3fd24c	153
07a3cd5c BP	154	\f
	155	/* Backers.
	156	*
	157	* A "backer" is the datapath (dpif) on which an dpif-based bridge (an
	158	* ofproto-dpif) resides. A backer can host several bridges, but a bridge is
	159	* backed by only a single dpif. */
e1ec7dd4	160
b440dd8c	161
1c2f091b AZ	162	/* DPIF_SUPPORT_FIELD(TYPE, FIELD_NAME, FIELD_DESCRIPTION)
	163	*
	164	* Each 'DPIF_SUPPORT_FIELD' defines a member in 'struct dpif_backer_support'
	165	* and represents support for a datapath action.
	166	* They are defined as macros to keep 'dpif_show_support()' in sync
	167	* as new fields are added. */
	168	#define DPIF_SUPPORT_FIELDS \
1c2f091b AZ	169	/* True if the datapath supports masked data in OVS_ACTION_ATTR_SET \
	170	* actions. */ \
	171	DPIF_SUPPORT_FIELD(bool, masked_set_action, "Masked set action") \
	172	\
	173	/* True if the datapath supports tnl_push and pop actions. */ \
	174	DPIF_SUPPORT_FIELD(bool, tnl_push_pop, "Tunnel push pop") \
	175	\
	176	/* True if the datapath supports OVS_FLOW_ATTR_UFID. */ \
	177	DPIF_SUPPORT_FIELD(bool, ufid, "Ufid") \
	178	\
	179	/* True if the datapath supports OVS_ACTION_ATTR_TRUNC action. */ \
	180	DPIF_SUPPORT_FIELD(bool, trunc, "Truncate action") \
	181	\
	182	/* True if the datapath supports OVS_ACTION_ATTR_CLONE action. */ \
	183	DPIF_SUPPORT_FIELD(bool, clone, "Clone action") \
	184	\
	185	/* Maximum level of nesting allowed by OVS_ACTION_ATTR_SAMPLE action. */\
adfe7a0b JR	186	DPIF_SUPPORT_FIELD(size_t, sample_nesting, "Sample nesting") \
	187	\
	188	/* OVS_CT_ATTR_EVENTMASK supported by OVS_ACTION_ATTR_CT action. */ \
1fe178d2 EG	189	DPIF_SUPPORT_FIELD(bool, ct_eventmask, "Conntrack eventmask") \
	190	\
	191	/* True if the datapath supports OVS_ACTION_ATTR_CT_CLEAR action. */ \
6a0b0d3b JS	192	DPIF_SUPPORT_FIELD(bool, ct_clear, "Conntrack clear") \
	193	\
	194	/* Highest supported dp_hash algorithm. */ \
	195	DPIF_SUPPORT_FIELD(size_t, max_hash_alg, "Max dp_hash algorithm")
2494ccd7	196
1c2f091b AZ	197	/* Stores the various features which the corresponding backer supports. */
	198	struct dpif_backer_support {
	199	#define DPIF_SUPPORT_FIELD(TYPE, NAME, TITLE) TYPE NAME;
	200	DPIF_SUPPORT_FIELDS
	201	#undef DPIF_SUPPORT_FIELD
aaca4fe0	202
2494ccd7 JS	203	/* Each member represents support for related OVS_KEY_ATTR_* fields. */
2494ccd7 JS	204	struct odp_support odp;
b440dd8c JS	205	};
b440dd8c JS	206
07a3cd5c BP	207	/* Reasons that we might need to revalidate every datapath flow, and
	208	* corresponding coverage counters.
	209	*
	210	* A value of 0 means that there is no need to revalidate.
	211	*
	212	* It would be nice to have some cleaner way to integrate with coverage
	213	* counters, but with only a few reasons I guess this is good enough for
	214	* now. */
	215	enum revalidate_reason {
	216	REV_RECONFIGURE = 1, /* Switch configuration changed. */
	217	REV_STP, /* Spanning tree protocol port status change. */
	218	REV_RSTP, /* RSTP port status change. */
	219	REV_BOND, /* Bonding changed. */
	220	REV_PORT_TOGGLED, /* Port enabled or disabled by CFM, LACP, ...*/
	221	REV_FLOW_TABLE, /* Flow table changed. */
	222	REV_MAC_LEARNING, /* Mac learning changed. */
	223	REV_MCAST_SNOOPING, /* Multicast snooping changed. */
	224	};
621b8064	225
07a3cd5c BP	226	/* All datapaths of a given type share a single dpif backer instance. */
	227	struct dpif_backer {
	228	char *type;
	229	int refcount;
	230	struct dpif *dpif;
	231	struct udpif *udpif;
a027899e	232
07a3cd5c BP	233	struct ovs_rwlock odp_to_ofport_lock;
07a3cd5c BP	234	struct hmap odp_to_ofport_map OVS_GUARDED; /* Contains "struct ofport"s. */
a027899e	235
07a3cd5c	236	struct simap tnl_backers; /* Set of dpif ports backing tunnels. */
70742c7f	237
07a3cd5c	238	enum revalidate_reason need_revalidate; /* Revalidate all flows. */
70742c7f	239
07a3cd5c	240	bool recv_set_enable; /* Enables or disables receiving packets. */
70742c7f	241
333ad77d AZ	242	/* Meter. */
	243	struct id_pool meter_ids; / Datapath meter allocation. */
	244
07a3cd5c BP	245	/* Version string of the datapath stored in OVSDB. */
07a3cd5c BP	246	char *dp_version_string;
003ce655	247
07a3cd5c	248	/* Datapath feature support. */
88186383 AZ	249	struct dpif_backer_support bt_support; /* Boot time support. Set once
	250	when vswitch starts up, then
	251	it is read only through out
	252	the life time of vswitchd. */
	253	struct dpif_backer_support rt_support; /* Runtime support. Can be
	254	set to a lower level in
	255	feature than 'bt_support'. */
	256
07a3cd5c BP	257	struct atomic_count tnl_count;
07a3cd5c BP	258	};
70742c7f	259
07a3cd5c BP	260	/* All existing ofproto_backer instances, indexed by ofproto->up.type. */
07a3cd5c BP	261	extern struct shash all_dpif_backers;
56c091ec	262
07a3cd5c BP	263	struct ofport_dpif odp_port_to_ofport(const struct dpif_backer , odp_port_t);
	264	\f
	265	/* A bridge based on a "dpif" datapath. */
	266
	267	struct ofproto_dpif {
911b4a7e JP	268	/* In 'all_ofproto_dpifs_by_name'. */
	269	struct hmap_node all_ofproto_dpifs_by_name_node;
	270
	271	/* In 'all_ofproto_dpifs_by_uuid'. */
	272	struct hmap_node all_ofproto_dpifs_by_uuid_node;
	273
07a3cd5c BP	274	struct ofproto up;
	275	struct dpif_backer *backer;
	276
	277	/* Unique identifier for this instantiation of this bridge in this running
	278	* process. */
	279	struct uuid uuid;
	280
	281	ATOMIC(ovs_version_t) tables_version; /* For classifier lookups. */
	282
	283	uint64_t dump_seq; /* Last read of udpif_dump_seq(). */
	284
	285	/* Special OpenFlow rules. */
	286	struct rule_dpif miss_rule; / Sends flow table misses to controller. */
	287	struct rule_dpif no_packet_in_rule; / Drops flow table misses. */
	288	struct rule_dpif drop_frags_rule; / Used in OFPUTIL_FRAG_DROP mode. */
	289
	290	/* Bridging. */
	291	struct netflow *netflow;
	292	struct dpif_sflow *sflow;
	293	struct dpif_ipfix *ipfix;
	294	struct hmap bundles; /* Contains "struct ofbundle"s. */
	295	struct mac_learning *ml;
	296	struct mcast_snooping *ms;
	297	bool has_bonded_bundles;
	298	bool lacp_enabled;
	299	struct mbridge *mbridge;
	300
	301	struct ovs_mutex stats_mutex;
	302	struct netdev_stats stats OVS_GUARDED; /* To account packets generated and
	303	* consumed in userspace. */
	304
	305	/* Spanning tree. */
	306	struct stp *stp;
	307	long long int stp_last_tick;
	308
	309	/* Rapid Spanning Tree. */
	310	struct rstp *rstp;
	311	long long int rstp_last_tick;
	312
	313	/* Ports. */
	314	struct sset ports; /* Set of standard port names. */
	315	struct sset ghost_ports; /* Ports with no datapath port. */
	316	struct sset port_poll_set; /* Queued names for port_poll() reply. */
	317	int port_poll_errno; /* Last errno for port_poll() reply. */
	318	uint64_t change_seq; /* Connectivity status changes. */
	319
	320	/* Work queues. */
	321	struct guarded_list ams; /* Contains "struct ofproto_async_msgs"s. */
	322	struct seq ams_seq; / For notifying 'ams' reception. */
	323	uint64_t ams_seqno;
	324	};
ad3efdcb	325
911b4a7e JP	326	struct ofproto_dpif ofproto_dpif_lookup_by_name(const char name);
911b4a7e JP	327	struct ofproto_dpif ofproto_dpif_lookup_by_uuid(const struct uuid uuid);
d13ee228	328
07a3cd5c	329	ovs_version_t ofproto_dpif_get_tables_version(struct ofproto_dpif *);
9583bc14	330
07a3cd5c BP	331	void ofproto_dpif_credit_table_stats(struct ofproto_dpif *, uint8_t table_id,
07a3cd5c BP	332	uint64_t n_matches, uint64_t n_misses);
f4fb341b	333
1f4a8933 JR	334	int ofproto_dpif_execute_actions(struct ofproto_dpif *, ovs_version_t,
	335	const struct flow , struct rule_dpif ,
	336	const struct ofpact *, size_t ofpacts_len,
	337	struct dp_packet *);
	338	int ofproto_dpif_execute_actions__(struct ofproto_dpif *, ovs_version_t,
	339	const struct flow , struct rule_dpif ,
	340	const struct ofpact *, size_t ofpacts_len,
2d9b49dd	341	int depth, int resubmits,
790c5d26	342	struct dp_packet *);
a2b53dec BP	343	void ofproto_dpif_send_async_msg(struct ofproto_dpif *,
a2b53dec BP	344	struct ofproto_async_msg *);
2eb79142 JG	345	int ofproto_dpif_send_packet(const struct ofport_dpif *, bool oam,
2eb79142 JG	346	struct dp_packet *);
07a3cd5c BP	347	enum ofperr ofproto_dpif_flow_mod_init_for_learn(
	348	struct ofproto_dpif , const struct ofputil_flow_mod ,
	349	struct ofproto_flow_mod *);
46c88433	350
e672ff9b JR	351	struct ofport_dpif ofp_port_to_ofport(const struct ofproto_dpif ,
e672ff9b JR	352	ofp_port_t);
8449c4d6	353
adcf00ba	354	int ofproto_dpif_add_internal_flow(struct ofproto_dpif *,
6a6b7060	355	struct match *, int priority,
290ad78a	356	uint16_t idle_timeout,
adcf00ba AZ	357	const struct ofpbuf *ofpacts,
	358	struct rule **rulep);
	359	int ofproto_dpif_delete_internal_flow(struct ofproto_dpif , struct match ,
	360	int priority);
290835f9	361
07a3cd5c	362	bool ovs_native_tunneling_is_on(struct ofproto_dpif *);
003ce655	363
9583bc14	364	#endif /* ofproto-dpif.h */