#include "ofproto/ofproto-dpif-xlate.h"
#include <errno.h>
+#include <arpa/inet.h>
+#include <net/if.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include "tnl-arp-cache.h"
#include "bfd.h"
#include "bitmap.h"
#include "bond.h"
#include "learn.h"
#include "list.h"
#include "mac-learning.h"
+#include "mcast-snooping.h"
#include "meta-flow.h"
#include "multipath.h"
#include "netdev-vport.h"
#include "ofproto/ofproto-dpif-sflow.h"
#include "ofproto/ofproto-dpif.h"
#include "ofproto/ofproto-provider.h"
+#include "packet-dpif.h"
+#include "ovs-router.h"
+#include "tnl-ports.h"
#include "tunnel.h"
#include "vlog.h"
COVERAGE_DEFINE(xlate_actions);
COVERAGE_DEFINE(xlate_actions_oversize);
+COVERAGE_DEFINE(xlate_actions_too_many_output);
COVERAGE_DEFINE(xlate_actions_mpls_overflow);
VLOG_DEFINE_THIS_MODULE(ofproto_dpif_xlate);
/* Maximum depth of flow table recursion (due to resubmit actions) in a
* flow translation. */
#define MAX_RESUBMIT_RECURSION 64
+#define MAX_INTERNAL_RESUBMITS 1 /* Max resbmits allowed using rules in
+ internal table. */
+
+/* Timeout for internal rules created to handle recirculation */
+#define RECIRC_TIMEOUT 60
/* Maximum number of resubmit actions in a flow translation, whether they are
* recursive or not. */
#define MAX_RESUBMITS (MAX_RESUBMIT_RECURSION * MAX_RESUBMIT_RECURSION)
-struct ovs_rwlock xlate_rwlock = OVS_RWLOCK_INITIALIZER;
-
struct xbridge {
struct hmap_node hmap_node; /* Node in global 'xbridges' map. */
struct ofproto_dpif *ofproto; /* Key in global 'xbridges' map. */
char *name; /* Name used in log messages. */
struct dpif *dpif; /* Datapath interface. */
struct mac_learning *ml; /* Mac learning handle. */
+ struct mcast_snooping *ms; /* Multicast Snooping handle. */
struct mbridge *mbridge; /* Mirroring. */
struct dpif_sflow *sflow; /* SFlow handle, or null. */
struct dpif_ipfix *ipfix; /* Ipfix handle, or null. */
struct netflow *netflow; /* Netflow handle, or null. */
struct stp *stp; /* STP or null if disabled. */
+ struct rstp *rstp; /* RSTP or null if disabled. */
- /* Special rules installed by ofproto-dpif. */
- struct rule_dpif *miss_rule;
- struct rule_dpif *no_packet_in_rule;
-
- enum ofp_config_flags frag; /* Fragmentation handling. */
bool has_in_band; /* Bridge has in band control? */
bool forward_bpdu; /* Bridge forwards STP BPDUs? */
+ /* True if the datapath supports recirculation. */
+ bool enable_recirc;
+
/* True if the datapath supports variable-length
* OVS_USERSPACE_ATTR_USERDATA in OVS_ACTION_ATTR_USERSPACE actions.
* False if the datapath supports only 8-byte (or shorter) userdata. */
/* Number of MPLS label stack entries that the datapath supports
* in matches. */
size_t max_mpls_depth;
+
+ /* True if the datapath supports masked data in OVS_ACTION_ATTR_SET
+ * actions. */
+ bool masked_set_action;
};
struct xbundle {
enum ofputil_port_config config; /* OpenFlow port configuration. */
enum ofputil_port_state state; /* OpenFlow port state. */
int stp_port_no; /* STP port number or -1 if not in use. */
+ struct rstp_port *rstp_port; /* RSTP port or null. */
struct hmap skb_priorities; /* Map of 'skb_priority_to_dscp's. */
uint16_t user_cookie_offset;/* Used for user_action_cookie fixup. */
bool exit; /* No further actions should be processed. */
+ bool use_recirc; /* Should generate recirc? */
+ struct xlate_recirc recirc; /* Information used for generating
+ * recirculation actions */
+
+ /* True if a packet was but is no longer MPLS (due to an MPLS pop action).
+ * This is a trigger for recirculation in cases where translating an action
+ * or looking up a flow requires access to the fields of the packet after
+ * the MPLS label stack that was originally present. */
+ bool was_mpls;
+
/* OpenFlow 1.1+ action set.
*
* 'action_set' accumulates "struct ofpact"s added by OFPACT_WRITE_ACTIONS.
* When translation is otherwise complete, ofpacts_execute_action_set()
* converts it to a set of "struct ofpact"s that can be translated into
* datapath actions. */
+ bool action_set_has_group; /* Action set contains OFPACT_GROUP? */
struct ofpbuf action_set; /* Action set. */
uint64_t action_set_stub[1024 / 8];
};
uint8_t dscp; /* DSCP bits to mark outgoing traffic with. */
};
-static struct hmap xbridges = HMAP_INITIALIZER(&xbridges);
-static struct hmap xbundles = HMAP_INITIALIZER(&xbundles);
-static struct hmap xports = HMAP_INITIALIZER(&xports);
+enum xc_type {
+ XC_RULE,
+ XC_BOND,
+ XC_NETDEV,
+ XC_NETFLOW,
+ XC_MIRROR,
+ XC_LEARN,
+ XC_NORMAL,
+ XC_FIN_TIMEOUT,
+ XC_GROUP,
+ XC_TNL_ARP,
+};
+
+/* xlate_cache entries hold enough information to perform the side effects of
+ * xlate_actions() for a rule, without needing to perform rule translation
+ * from scratch. The primary usage of these is to submit statistics to objects
+ * that a flow relates to, although they may be used for other effects as well
+ * (for instance, refreshing hard timeouts for learned flows). */
+struct xc_entry {
+ enum xc_type type;
+ union {
+ struct rule_dpif *rule;
+ struct {
+ struct netdev *tx;
+ struct netdev *rx;
+ struct bfd *bfd;
+ } dev;
+ struct {
+ struct netflow *netflow;
+ struct flow *flow;
+ ofp_port_t iface;
+ } nf;
+ struct {
+ struct mbridge *mbridge;
+ mirror_mask_t mirrors;
+ } mirror;
+ struct {
+ struct bond *bond;
+ struct flow *flow;
+ uint16_t vid;
+ } bond;
+ struct {
+ struct ofproto_dpif *ofproto;
+ struct ofputil_flow_mod *fm;
+ struct ofpbuf *ofpacts;
+ } learn;
+ struct {
+ struct ofproto_dpif *ofproto;
+ struct flow *flow;
+ int vlan;
+ } normal;
+ struct {
+ struct rule_dpif *rule;
+ uint16_t idle;
+ uint16_t hard;
+ } fin;
+ struct {
+ struct group_dpif *group;
+ struct ofputil_bucket *bucket;
+ } group;
+ struct {
+ char br_name[IFNAMSIZ];
+ ovs_be32 d_ip;
+ } tnl_arp_cache;
+ } u;
+};
+
+#define XC_ENTRY_FOR_EACH(entry, entries, xcache) \
+ entries = xcache->entries; \
+ for (entry = ofpbuf_try_pull(&entries, sizeof *entry); \
+ entry; \
+ entry = ofpbuf_try_pull(&entries, sizeof *entry))
+
+struct xlate_cache {
+ struct ofpbuf entries;
+};
+
+/* Xlate config contains hash maps of all bridges, bundles and ports.
+ * Xcfgp contains the pointer to the current xlate configuration.
+ * When the main thread needs to change the configuration, it copies xcfgp to
+ * new_xcfg and edits new_xcfg. This enables the use of RCU locking which
+ * does not block handler and revalidator threads. */
+struct xlate_cfg {
+ struct hmap xbridges;
+ struct hmap xbundles;
+ struct hmap xports;
+};
+static OVSRCU_TYPE(struct xlate_cfg *) xcfgp = OVSRCU_INITIALIZER(NULL);
+static struct xlate_cfg *new_xcfg = NULL;
static bool may_receive(const struct xport *, struct xlate_ctx *);
static void do_xlate_actions(const struct ofpact *, size_t ofpacts_len,
struct xlate_ctx *);
-static void xlate_actions__(struct xlate_in *, struct xlate_out *)
- OVS_REQ_RDLOCK(xlate_rwlock);
- static void xlate_normal(struct xlate_ctx *);
- static void xlate_report(struct xlate_ctx *, const char *);
+static void xlate_normal(struct xlate_ctx *);
+static inline void xlate_report(struct xlate_ctx *, const char *);
static void xlate_table_action(struct xlate_ctx *, ofp_port_t in_port,
uint8_t table_id, bool may_packet_in,
bool honor_table_miss);
uint16_t vlan);
static void compose_output_action(struct xlate_ctx *, ofp_port_t ofp_port);
-static struct xbridge *xbridge_lookup(const struct ofproto_dpif *);
-static struct xbundle *xbundle_lookup(const struct ofbundle *);
-static struct xport *xport_lookup(const struct ofport_dpif *);
+static struct xbridge *xbridge_lookup(struct xlate_cfg *,
+ const struct ofproto_dpif *);
+static struct xbundle *xbundle_lookup(struct xlate_cfg *,
+ const struct ofbundle *);
+static struct xport *xport_lookup(struct xlate_cfg *,
+ const struct ofport_dpif *);
static struct xport *get_ofp_port(const struct xbridge *, ofp_port_t ofp_port);
static struct skb_priority_to_dscp *get_skb_priority(const struct xport *,
uint32_t skb_priority);
static void clear_skb_priorities(struct xport *);
+static size_t count_skb_priorities(const struct xport *);
static bool dscp_from_skb_priority(const struct xport *, uint32_t skb_priority,
uint8_t *dscp);
-void
-xlate_ofproto_set(struct ofproto_dpif *ofproto, const char *name,
- struct dpif *dpif, struct rule_dpif *miss_rule,
- struct rule_dpif *no_packet_in_rule,
+static struct xc_entry *xlate_cache_add_entry(struct xlate_cache *xc,
+ enum xc_type type);
+static void xlate_xbridge_init(struct xlate_cfg *, struct xbridge *);
+static void xlate_xbundle_init(struct xlate_cfg *, struct xbundle *);
+static void xlate_xport_init(struct xlate_cfg *, struct xport *);
+static void xlate_xbridge_set(struct xbridge *, struct dpif *,
+ const struct mac_learning *, struct stp *,
+ struct rstp *, const struct mcast_snooping *,
+ const struct mbridge *,
+ const struct dpif_sflow *,
+ const struct dpif_ipfix *,
+ const struct netflow *,
+ bool forward_bpdu, bool has_in_band,
+ bool enable_recirc,
+ bool variable_length_userdata,
+ size_t max_mpls_depth,
+ bool masked_set_action);
+static void xlate_xbundle_set(struct xbundle *xbundle,
+ enum port_vlan_mode vlan_mode, int vlan,
+ unsigned long *trunks, bool use_priority_tags,
+ const struct bond *bond, const struct lacp *lacp,
+ bool floodable);
+static void xlate_xport_set(struct xport *xport, odp_port_t odp_port,
+ const struct netdev *netdev, const struct cfm *cfm,
+ const struct bfd *bfd, int stp_port_no,
+ const struct rstp_port *rstp_port,
+ enum ofputil_port_config config,
+ enum ofputil_port_state state, bool is_tunnel,
+ bool may_enable);
+static void xlate_xbridge_remove(struct xlate_cfg *, struct xbridge *);
+static void xlate_xbundle_remove(struct xlate_cfg *, struct xbundle *);
+static void xlate_xport_remove(struct xlate_cfg *, struct xport *);
+static void xlate_xbridge_copy(struct xbridge *);
+static void xlate_xbundle_copy(struct xbridge *, struct xbundle *);
+static void xlate_xport_copy(struct xbridge *, struct xbundle *,
+ struct xport *);
+static void xlate_xcfg_free(struct xlate_cfg *);
+
+static inline void
+xlate_report(struct xlate_ctx *ctx, const char *s)
+{
+ if (OVS_UNLIKELY(ctx->xin->report_hook)) {
+ ctx->xin->report_hook(ctx->xin, s, ctx->recurse);
+ }
+}
+
+static void
+xlate_xbridge_init(struct xlate_cfg *xcfg, struct xbridge *xbridge)
+{
+ list_init(&xbridge->xbundles);
+ hmap_init(&xbridge->xports);
+ hmap_insert(&xcfg->xbridges, &xbridge->hmap_node,
+ hash_pointer(xbridge->ofproto, 0));
+}
+
+static void
+xlate_xbundle_init(struct xlate_cfg *xcfg, struct xbundle *xbundle)
+{
+ list_init(&xbundle->xports);
+ list_insert(&xbundle->xbridge->xbundles, &xbundle->list_node);
+ hmap_insert(&xcfg->xbundles, &xbundle->hmap_node,
+ hash_pointer(xbundle->ofbundle, 0));
+}
+
+static void
+xlate_xport_init(struct xlate_cfg *xcfg, struct xport *xport)
+{
+ hmap_init(&xport->skb_priorities);
+ hmap_insert(&xcfg->xports, &xport->hmap_node,
+ hash_pointer(xport->ofport, 0));
+ hmap_insert(&xport->xbridge->xports, &xport->ofp_node,
+ hash_ofp_port(xport->ofp_port));
+}
+
+static void
+xlate_xbridge_set(struct xbridge *xbridge,
+ struct dpif *dpif,
const struct mac_learning *ml, struct stp *stp,
+ struct rstp *rstp, const struct mcast_snooping *ms,
const struct mbridge *mbridge,
const struct dpif_sflow *sflow,
const struct dpif_ipfix *ipfix,
- const struct netflow *netflow, enum ofp_config_flags frag,
+ const struct netflow *netflow,
bool forward_bpdu, bool has_in_band,
+ bool enable_recirc,
bool variable_length_userdata,
- size_t max_mpls_depth)
+ size_t max_mpls_depth,
+ bool masked_set_action)
{
- struct xbridge *xbridge = xbridge_lookup(ofproto);
-
- if (!xbridge) {
- xbridge = xzalloc(sizeof *xbridge);
- xbridge->ofproto = ofproto;
-
- hmap_insert(&xbridges, &xbridge->hmap_node, hash_pointer(ofproto, 0));
- hmap_init(&xbridge->xports);
- list_init(&xbridge->xbundles);
- }
-
if (xbridge->ml != ml) {
mac_learning_unref(xbridge->ml);
xbridge->ml = mac_learning_ref(ml);
}
+ if (xbridge->ms != ms) {
+ mcast_snooping_unref(xbridge->ms);
+ xbridge->ms = mcast_snooping_ref(ms);
+ }
+
if (xbridge->mbridge != mbridge) {
mbridge_unref(xbridge->mbridge);
xbridge->mbridge = mbridge_ref(mbridge);
xbridge->stp = stp_ref(stp);
}
+ if (xbridge->rstp != rstp) {
+ rstp_unref(xbridge->rstp);
+ xbridge->rstp = rstp_ref(rstp);
+ }
+
if (xbridge->netflow != netflow) {
netflow_unref(xbridge->netflow);
xbridge->netflow = netflow_ref(netflow);
}
- free(xbridge->name);
- xbridge->name = xstrdup(name);
-
xbridge->dpif = dpif;
xbridge->forward_bpdu = forward_bpdu;
xbridge->has_in_band = has_in_band;
- xbridge->frag = frag;
- xbridge->miss_rule = miss_rule;
- xbridge->no_packet_in_rule = no_packet_in_rule;
+ xbridge->enable_recirc = enable_recirc;
xbridge->variable_length_userdata = variable_length_userdata;
xbridge->max_mpls_depth = max_mpls_depth;
+ xbridge->masked_set_action = masked_set_action;
+}
+
+static void
+xlate_xbundle_set(struct xbundle *xbundle,
+ enum port_vlan_mode vlan_mode, int vlan,
+ unsigned long *trunks, bool use_priority_tags,
+ const struct bond *bond, const struct lacp *lacp,
+ bool floodable)
+{
+ ovs_assert(xbundle->xbridge);
+
+ xbundle->vlan_mode = vlan_mode;
+ xbundle->vlan = vlan;
+ xbundle->trunks = trunks;
+ xbundle->use_priority_tags = use_priority_tags;
+ xbundle->floodable = floodable;
+
+ if (xbundle->bond != bond) {
+ bond_unref(xbundle->bond);
+ xbundle->bond = bond_ref(bond);
+ }
+
+ if (xbundle->lacp != lacp) {
+ lacp_unref(xbundle->lacp);
+ xbundle->lacp = lacp_ref(lacp);
+ }
+}
+
+static void
+xlate_xport_set(struct xport *xport, odp_port_t odp_port,
+ const struct netdev *netdev, const struct cfm *cfm,
+ const struct bfd *bfd, int stp_port_no,
+ const struct rstp_port* rstp_port,
+ enum ofputil_port_config config, enum ofputil_port_state state,
+ bool is_tunnel, bool may_enable)
+{
+ xport->config = config;
+ xport->state = state;
+ xport->stp_port_no = stp_port_no;
+ xport->is_tunnel = is_tunnel;
+ xport->may_enable = may_enable;
+ xport->odp_port = odp_port;
+
+ if (xport->rstp_port != rstp_port) {
+ rstp_port_unref(xport->rstp_port);
+ xport->rstp_port = rstp_port_ref(rstp_port);
+ }
+
+ if (xport->cfm != cfm) {
+ cfm_unref(xport->cfm);
+ xport->cfm = cfm_ref(cfm);
+ }
+
+ if (xport->bfd != bfd) {
+ bfd_unref(xport->bfd);
+ xport->bfd = bfd_ref(bfd);
+ }
+
+ if (xport->netdev != netdev) {
+ netdev_close(xport->netdev);
+ xport->netdev = netdev_ref(netdev);
+ }
+}
+
+static void
+xlate_xbridge_copy(struct xbridge *xbridge)
+{
+ struct xbundle *xbundle;
+ struct xport *xport;
+ struct xbridge *new_xbridge = xzalloc(sizeof *xbridge);
+ new_xbridge->ofproto = xbridge->ofproto;
+ new_xbridge->name = xstrdup(xbridge->name);
+ xlate_xbridge_init(new_xcfg, new_xbridge);
+
+ xlate_xbridge_set(new_xbridge,
+ xbridge->dpif, xbridge->ml, xbridge->stp,
+ xbridge->rstp, xbridge->ms, xbridge->mbridge,
+ xbridge->sflow, xbridge->ipfix, xbridge->netflow,
+ xbridge->forward_bpdu,
+ xbridge->has_in_band, xbridge->enable_recirc,
+ xbridge->variable_length_userdata,
+ xbridge->max_mpls_depth, xbridge->masked_set_action);
+ LIST_FOR_EACH (xbundle, list_node, &xbridge->xbundles) {
+ xlate_xbundle_copy(new_xbridge, xbundle);
+ }
+
+ /* Copy xports which are not part of a xbundle */
+ HMAP_FOR_EACH (xport, ofp_node, &xbridge->xports) {
+ if (!xport->xbundle) {
+ xlate_xport_copy(new_xbridge, NULL, xport);
+ }
+ }
+}
+
+static void
+xlate_xbundle_copy(struct xbridge *xbridge, struct xbundle *xbundle)
+{
+ struct xport *xport;
+ struct xbundle *new_xbundle = xzalloc(sizeof *xbundle);
+ new_xbundle->ofbundle = xbundle->ofbundle;
+ new_xbundle->xbridge = xbridge;
+ new_xbundle->name = xstrdup(xbundle->name);
+ xlate_xbundle_init(new_xcfg, new_xbundle);
+
+ xlate_xbundle_set(new_xbundle, xbundle->vlan_mode,
+ xbundle->vlan, xbundle->trunks,
+ xbundle->use_priority_tags, xbundle->bond, xbundle->lacp,
+ xbundle->floodable);
+ LIST_FOR_EACH (xport, bundle_node, &xbundle->xports) {
+ xlate_xport_copy(xbridge, new_xbundle, xport);
+ }
}
+static void
+xlate_xport_copy(struct xbridge *xbridge, struct xbundle *xbundle,
+ struct xport *xport)
+{
+ struct skb_priority_to_dscp *pdscp, *new_pdscp;
+ struct xport *new_xport = xzalloc(sizeof *xport);
+ new_xport->ofport = xport->ofport;
+ new_xport->ofp_port = xport->ofp_port;
+ new_xport->xbridge = xbridge;
+ xlate_xport_init(new_xcfg, new_xport);
+
+ xlate_xport_set(new_xport, xport->odp_port, xport->netdev, xport->cfm,
+ xport->bfd, xport->stp_port_no, xport->rstp_port,
+ xport->config, xport->state, xport->is_tunnel,
+ xport->may_enable);
+
+ if (xport->peer) {
+ struct xport *peer = xport_lookup(new_xcfg, xport->peer->ofport);
+ if (peer) {
+ new_xport->peer = peer;
+ new_xport->peer->peer = new_xport;
+ }
+ }
+
+ if (xbundle) {
+ new_xport->xbundle = xbundle;
+ list_insert(&new_xport->xbundle->xports, &new_xport->bundle_node);
+ }
+
+ HMAP_FOR_EACH (pdscp, hmap_node, &xport->skb_priorities) {
+ new_pdscp = xmalloc(sizeof *pdscp);
+ new_pdscp->skb_priority = pdscp->skb_priority;
+ new_pdscp->dscp = pdscp->dscp;
+ hmap_insert(&new_xport->skb_priorities, &new_pdscp->hmap_node,
+ hash_int(new_pdscp->skb_priority, 0));
+ }
+}
+
+/* Sets the current xlate configuration to new_xcfg and frees the old xlate
+ * configuration in xcfgp.
+ *
+ * This needs to be called after editing the xlate configuration.
+ *
+ * Functions that edit the new xlate configuration are
+ * xlate_<ofport/bundle/ofport>_set and xlate_<ofport/bundle/ofport>_remove.
+ *
+ * A sample workflow:
+ *
+ * xlate_txn_start();
+ * ...
+ * edit_xlate_configuration();
+ * ...
+ * xlate_txn_commit(); */
void
-xlate_remove_ofproto(struct ofproto_dpif *ofproto)
+xlate_txn_commit(void)
+{
+ struct xlate_cfg *xcfg = ovsrcu_get(struct xlate_cfg *, &xcfgp);
+
+ ovsrcu_set(&xcfgp, new_xcfg);
+ ovsrcu_synchronize();
+ xlate_xcfg_free(xcfg);
+ new_xcfg = NULL;
+}
+
+/* Copies the current xlate configuration in xcfgp to new_xcfg.
+ *
+ * This needs to be called prior to editing the xlate configuration. */
+void
+xlate_txn_start(void)
+{
+ struct xbridge *xbridge;
+ struct xlate_cfg *xcfg;
+
+ ovs_assert(!new_xcfg);
+
+ new_xcfg = xmalloc(sizeof *new_xcfg);
+ hmap_init(&new_xcfg->xbridges);
+ hmap_init(&new_xcfg->xbundles);
+ hmap_init(&new_xcfg->xports);
+
+ xcfg = ovsrcu_get(struct xlate_cfg *, &xcfgp);
+ if (!xcfg) {
+ return;
+ }
+
+ HMAP_FOR_EACH (xbridge, hmap_node, &xcfg->xbridges) {
+ xlate_xbridge_copy(xbridge);
+ }
+}
+
+
+static void
+xlate_xcfg_free(struct xlate_cfg *xcfg)
+{
+ struct xbridge *xbridge, *next_xbridge;
+
+ if (!xcfg) {
+ return;
+ }
+
+ HMAP_FOR_EACH_SAFE (xbridge, next_xbridge, hmap_node, &xcfg->xbridges) {
+ xlate_xbridge_remove(xcfg, xbridge);
+ }
+
+ hmap_destroy(&xcfg->xbridges);
+ hmap_destroy(&xcfg->xbundles);
+ hmap_destroy(&xcfg->xports);
+ free(xcfg);
+}
+
+void
+xlate_ofproto_set(struct ofproto_dpif *ofproto, const char *name,
+ struct dpif *dpif,
+ const struct mac_learning *ml, struct stp *stp,
+ struct rstp *rstp, const struct mcast_snooping *ms,
+ const struct mbridge *mbridge,
+ const struct dpif_sflow *sflow,
+ const struct dpif_ipfix *ipfix,
+ const struct netflow *netflow,
+ bool forward_bpdu, bool has_in_band, bool enable_recirc,
+ bool variable_length_userdata, size_t max_mpls_depth,
+ bool masked_set_action)
+{
+ struct xbridge *xbridge;
+
+ ovs_assert(new_xcfg);
+
+ xbridge = xbridge_lookup(new_xcfg, ofproto);
+ if (!xbridge) {
+ xbridge = xzalloc(sizeof *xbridge);
+ xbridge->ofproto = ofproto;
+
+ xlate_xbridge_init(new_xcfg, xbridge);
+ }
+
+ free(xbridge->name);
+ xbridge->name = xstrdup(name);
+
+ xlate_xbridge_set(xbridge, dpif, ml, stp, rstp, ms, mbridge, sflow, ipfix,
+ netflow, forward_bpdu, has_in_band, enable_recirc,
+ variable_length_userdata, max_mpls_depth,
+ masked_set_action);
+}
+
+static void
+xlate_xbridge_remove(struct xlate_cfg *xcfg, struct xbridge *xbridge)
{
- struct xbridge *xbridge = xbridge_lookup(ofproto);
struct xbundle *xbundle, *next_xbundle;
struct xport *xport, *next_xport;
}
HMAP_FOR_EACH_SAFE (xport, next_xport, ofp_node, &xbridge->xports) {
- xlate_ofport_remove(xport->ofport);
+ xlate_xport_remove(xcfg, xport);
}
LIST_FOR_EACH_SAFE (xbundle, next_xbundle, list_node, &xbridge->xbundles) {
- xlate_bundle_remove(xbundle->ofbundle);
+ xlate_xbundle_remove(xcfg, xbundle);
}
- hmap_remove(&xbridges, &xbridge->hmap_node);
+ hmap_remove(&xcfg->xbridges, &xbridge->hmap_node);
mac_learning_unref(xbridge->ml);
+ mcast_snooping_unref(xbridge->ms);
mbridge_unref(xbridge->mbridge);
dpif_sflow_unref(xbridge->sflow);
dpif_ipfix_unref(xbridge->ipfix);
stp_unref(xbridge->stp);
+ rstp_unref(xbridge->rstp);
hmap_destroy(&xbridge->xports);
free(xbridge->name);
free(xbridge);
}
+void
+xlate_remove_ofproto(struct ofproto_dpif *ofproto)
+{
+ struct xbridge *xbridge;
+
+ ovs_assert(new_xcfg);
+
+ xbridge = xbridge_lookup(new_xcfg, ofproto);
+ xlate_xbridge_remove(new_xcfg, xbridge);
+}
+
void
xlate_bundle_set(struct ofproto_dpif *ofproto, struct ofbundle *ofbundle,
const char *name, enum port_vlan_mode vlan_mode, int vlan,
const struct bond *bond, const struct lacp *lacp,
bool floodable)
{
- struct xbundle *xbundle = xbundle_lookup(ofbundle);
+ struct xbundle *xbundle;
+
+ ovs_assert(new_xcfg);
+ xbundle = xbundle_lookup(new_xcfg, ofbundle);
if (!xbundle) {
xbundle = xzalloc(sizeof *xbundle);
xbundle->ofbundle = ofbundle;
- xbundle->xbridge = xbridge_lookup(ofproto);
+ xbundle->xbridge = xbridge_lookup(new_xcfg, ofproto);
- hmap_insert(&xbundles, &xbundle->hmap_node, hash_pointer(ofbundle, 0));
- list_insert(&xbundle->xbridge->xbundles, &xbundle->list_node);
- list_init(&xbundle->xports);
+ xlate_xbundle_init(new_xcfg, xbundle);
}
- ovs_assert(xbundle->xbridge);
-
free(xbundle->name);
xbundle->name = xstrdup(name);
- xbundle->vlan_mode = vlan_mode;
- xbundle->vlan = vlan;
- xbundle->trunks = trunks;
- xbundle->use_priority_tags = use_priority_tags;
- xbundle->floodable = floodable;
-
- if (xbundle->bond != bond) {
- bond_unref(xbundle->bond);
- xbundle->bond = bond_ref(bond);
- }
-
- if (xbundle->lacp != lacp) {
- lacp_unref(xbundle->lacp);
- xbundle->lacp = lacp_ref(lacp);
- }
+ xlate_xbundle_set(xbundle, vlan_mode, vlan, trunks,
+ use_priority_tags, bond, lacp, floodable);
}
-void
-xlate_bundle_remove(struct ofbundle *ofbundle)
+static void
+xlate_xbundle_remove(struct xlate_cfg *xcfg, struct xbundle *xbundle)
{
- struct xbundle *xbundle = xbundle_lookup(ofbundle);
struct xport *xport, *next;
if (!xbundle) {
xport->xbundle = NULL;
}
- hmap_remove(&xbundles, &xbundle->hmap_node);
+ hmap_remove(&xcfg->xbundles, &xbundle->hmap_node);
list_remove(&xbundle->list_node);
bond_unref(xbundle->bond);
lacp_unref(xbundle->lacp);
free(xbundle);
}
+void
+xlate_bundle_remove(struct ofbundle *ofbundle)
+{
+ struct xbundle *xbundle;
+
+ ovs_assert(new_xcfg);
+
+ xbundle = xbundle_lookup(new_xcfg, ofbundle);
+ xlate_xbundle_remove(new_xcfg, xbundle);
+}
+
void
xlate_ofport_set(struct ofproto_dpif *ofproto, struct ofbundle *ofbundle,
struct ofport_dpif *ofport, ofp_port_t ofp_port,
odp_port_t odp_port, const struct netdev *netdev,
const struct cfm *cfm, const struct bfd *bfd,
struct ofport_dpif *peer, int stp_port_no,
+ const struct rstp_port *rstp_port,
const struct ofproto_port_queue *qdscp_list, size_t n_qdscp,
enum ofputil_port_config config,
enum ofputil_port_state state, bool is_tunnel,
bool may_enable)
{
- struct xport *xport = xport_lookup(ofport);
size_t i;
+ struct xport *xport;
+
+ ovs_assert(new_xcfg);
+ xport = xport_lookup(new_xcfg, ofport);
if (!xport) {
xport = xzalloc(sizeof *xport);
xport->ofport = ofport;
- xport->xbridge = xbridge_lookup(ofproto);
+ xport->xbridge = xbridge_lookup(new_xcfg, ofproto);
xport->ofp_port = ofp_port;
- hmap_init(&xport->skb_priorities);
- hmap_insert(&xports, &xport->hmap_node, hash_pointer(ofport, 0));
- hmap_insert(&xport->xbridge->xports, &xport->ofp_node,
- hash_ofp_port(xport->ofp_port));
+ xlate_xport_init(new_xcfg, xport);
}
ovs_assert(xport->ofp_port == ofp_port);
- xport->config = config;
- xport->state = state;
- xport->stp_port_no = stp_port_no;
- xport->is_tunnel = is_tunnel;
- xport->may_enable = may_enable;
- xport->odp_port = odp_port;
-
- if (xport->netdev != netdev) {
- netdev_close(xport->netdev);
- xport->netdev = netdev_ref(netdev);
- }
-
- if (xport->cfm != cfm) {
- cfm_unref(xport->cfm);
- xport->cfm = cfm_ref(cfm);
- }
-
- if (xport->bfd != bfd) {
- bfd_unref(xport->bfd);
- xport->bfd = bfd_ref(bfd);
- }
+ xlate_xport_set(xport, odp_port, netdev, cfm, bfd, stp_port_no,
+ rstp_port, config, state, is_tunnel, may_enable);
if (xport->peer) {
xport->peer->peer = NULL;
}
- xport->peer = xport_lookup(peer);
+ xport->peer = xport_lookup(new_xcfg, peer);
if (xport->peer) {
xport->peer->peer = xport;
}
if (xport->xbundle) {
list_remove(&xport->bundle_node);
}
- xport->xbundle = xbundle_lookup(ofbundle);
+ xport->xbundle = xbundle_lookup(new_xcfg, ofbundle);
if (xport->xbundle) {
list_insert(&xport->xbundle->xports, &xport->bundle_node);
}
}
}
-void
-xlate_ofport_remove(struct ofport_dpif *ofport)
+static void
+xlate_xport_remove(struct xlate_cfg *xcfg, struct xport *xport)
{
- struct xport *xport = xport_lookup(ofport);
-
if (!xport) {
return;
}
clear_skb_priorities(xport);
hmap_destroy(&xport->skb_priorities);
- hmap_remove(&xports, &xport->hmap_node);
+ hmap_remove(&xcfg->xports, &xport->hmap_node);
hmap_remove(&xport->xbridge->xports, &xport->ofp_node);
netdev_close(xport->netdev);
+ rstp_port_unref(xport->rstp_port);
cfm_unref(xport->cfm);
bfd_unref(xport->bfd);
free(xport);
}
-/* Given a datpath, packet, and flow metadata ('backer', 'packet', and 'key'
- * respectively), populates 'flow' with the result of odp_flow_key_to_flow().
- * Optionally populates 'ofproto' with the ofproto_dpif, 'odp_in_port' with
- * the datapath in_port, that 'packet' ingressed, and 'ipfix', 'sflow', and
- * 'netflow' with the appropriate handles for those protocols if they're
- * enabled. Caller is responsible for unrefing them.
- *
- * If 'ofproto' is nonnull, requires 'flow''s in_port to exist. Otherwise sets
- * 'flow''s in_port to OFPP_NONE.
- *
- * This function does post-processing on data returned from
- * odp_flow_key_to_flow() to help make VLAN splinters transparent to the rest
- * of the upcall processing logic. In particular, if the extracted in_port is
- * a VLAN splinter port, it replaces flow->in_port by the "real" port, sets
- * flow->vlan_tci correctly for the VLAN of the VLAN splinter port, and pushes
- * a VLAN header onto 'packet' (if it is nonnull).
+void
+xlate_ofport_remove(struct ofport_dpif *ofport)
+{
+ struct xport *xport;
+
+ ovs_assert(new_xcfg);
+
+ xport = xport_lookup(new_xcfg, ofport);
+ xlate_xport_remove(new_xcfg, xport);
+}
+
+/* Given a datapath and flow metadata ('backer', and 'flow' respectively)
+ * returns the corresponding struct xport, or NULL if none is found. */
+static struct xport *
+xlate_lookup_xport(const struct dpif_backer *backer, const struct flow *flow)
+{
+ struct xlate_cfg *xcfg = ovsrcu_get(struct xlate_cfg *, &xcfgp);
+
+ return xport_lookup(xcfg, tnl_port_should_receive(flow)
+ ? tnl_port_receive(flow)
+ : odp_port_to_ofport(backer, flow->in_port.odp_port));
+}
+
+static struct ofproto_dpif *
+xlate_lookup_ofproto_(const struct dpif_backer *backer, const struct flow *flow,
+ ofp_port_t *ofp_in_port, const struct xport **xportp)
+{
+ const struct xport *xport;
+
+ *xportp = xport = xlate_lookup_xport(backer, flow);
+
+ if (xport) {
+ if (ofp_in_port) {
+ *ofp_in_port = xport->ofp_port;
+ }
+ return xport->xbridge->ofproto;
+ }
+
+ return NULL;
+}
+
+/* Given a datapath and flow metadata ('backer', and 'flow' respectively)
+ * returns the corresponding struct ofproto_dpif and OpenFlow port number. */
+struct ofproto_dpif *
+xlate_lookup_ofproto(const struct dpif_backer *backer, const struct flow *flow,
+ ofp_port_t *ofp_in_port)
+{
+ const struct xport *xport;
+
+ return xlate_lookup_ofproto_(backer, flow, ofp_in_port, &xport);
+}
+
+/* Given a datapath and flow metadata ('backer', and 'flow' respectively),
+ * optionally populates 'ofproto' with the ofproto_dpif, 'ofp_in_port' with the
+ * openflow in_port, and 'ipfix', 'sflow', and 'netflow' with the appropriate
+ * handles for those protocols if they're enabled. Caller may use the returned
+ * pointers until quiescing, for longer term use additional references must
+ * be taken.
*
- * Similarly, this function also includes some logic to help with tunnels. It
- * may modify 'flow' as necessary to make the tunneling implementation
- * transparent to the upcall processing logic.
+ * '*ofp_in_port' is set to OFPP_NONE if 'flow''s in_port does not exist.
*
- * Returns 0 if successful, ENODEV if the parsed flow has no associated ofport,
- * or some other positive errno if there are other problems. */
+ * Returns 0 if successful, ENODEV if the parsed flow has no associated ofport.
+ */
int
-xlate_receive(const struct dpif_backer *backer, struct ofpbuf *packet,
- const struct nlattr *key, size_t key_len, struct flow *flow,
- struct ofproto_dpif **ofproto, struct dpif_ipfix **ipfix,
- struct dpif_sflow **sflow, struct netflow **netflow,
- odp_port_t *odp_in_port)
+xlate_lookup(const struct dpif_backer *backer, const struct flow *flow,
+ struct ofproto_dpif **ofprotop, struct dpif_ipfix **ipfix,
+ struct dpif_sflow **sflow, struct netflow **netflow,
+ ofp_port_t *ofp_in_port)
{
+ struct ofproto_dpif *ofproto;
const struct xport *xport;
- int error = ENODEV;
- ovs_rwlock_rdlock(&xlate_rwlock);
- if (odp_flow_key_to_flow(key, key_len, flow) == ODP_FIT_ERROR) {
- error = EINVAL;
- goto exit;
- }
+ ofproto = xlate_lookup_ofproto_(backer, flow, ofp_in_port, &xport);
- if (odp_in_port) {
- *odp_in_port = flow->in_port.odp_port;
+ if (ofp_in_port && !xport) {
+ *ofp_in_port = OFPP_NONE;
}
- xport = xport_lookup(tnl_port_should_receive(flow)
- ? tnl_port_receive(flow)
- : odp_port_to_ofport(backer, flow->in_port.odp_port));
-
- flow->in_port.ofp_port = xport ? xport->ofp_port : OFPP_NONE;
if (!xport) {
- goto exit;
+ return ENODEV;
}
- if (vsp_adjust_flow(xport->xbridge->ofproto, flow)) {
- if (packet) {
- /* Make the packet resemble the flow, so that it gets sent to
- * an OpenFlow controller properly, so that it looks correct
- * for sFlow, and so that flow_extract() will get the correct
- * vlan_tci if it is called on 'packet'. */
- eth_push_vlan(packet, htons(ETH_TYPE_VLAN), flow->vlan_tci);
- }
- }
- error = 0;
-
- if (ofproto) {
- *ofproto = xport->xbridge->ofproto;
+ if (ofprotop) {
+ *ofprotop = ofproto;
}
if (ipfix) {
- *ipfix = dpif_ipfix_ref(xport->xbridge->ipfix);
+ *ipfix = xport->xbridge->ipfix;
}
if (sflow) {
- *sflow = dpif_sflow_ref(xport->xbridge->sflow);
+ *sflow = xport->xbridge->sflow;
}
if (netflow) {
- *netflow = netflow_ref(xport->xbridge->netflow);
+ *netflow = xport->xbridge->netflow;
}
-
-exit:
- ovs_rwlock_unlock(&xlate_rwlock);
- return error;
+ return 0;
}
static struct xbridge *
-xbridge_lookup(const struct ofproto_dpif *ofproto)
+xbridge_lookup(struct xlate_cfg *xcfg, const struct ofproto_dpif *ofproto)
{
+ struct hmap *xbridges;
struct xbridge *xbridge;
- if (!ofproto) {
+ if (!ofproto || !xcfg) {
return NULL;
}
+ xbridges = &xcfg->xbridges;
+
HMAP_FOR_EACH_IN_BUCKET (xbridge, hmap_node, hash_pointer(ofproto, 0),
- &xbridges) {
+ xbridges) {
if (xbridge->ofproto == ofproto) {
return xbridge;
}
}
static struct xbundle *
-xbundle_lookup(const struct ofbundle *ofbundle)
+xbundle_lookup(struct xlate_cfg *xcfg, const struct ofbundle *ofbundle)
{
+ struct hmap *xbundles;
struct xbundle *xbundle;
- if (!ofbundle) {
+ if (!ofbundle || !xcfg) {
return NULL;
}
+ xbundles = &xcfg->xbundles;
+
HMAP_FOR_EACH_IN_BUCKET (xbundle, hmap_node, hash_pointer(ofbundle, 0),
- &xbundles) {
+ xbundles) {
if (xbundle->ofbundle == ofbundle) {
return xbundle;
}
}
static struct xport *
-xport_lookup(const struct ofport_dpif *ofport)
+xport_lookup(struct xlate_cfg *xcfg, const struct ofport_dpif *ofport)
{
+ struct hmap *xports;
struct xport *xport;
- if (!ofport) {
+ if (!ofport || !xcfg) {
return NULL;
}
+ xports = &xcfg->xports;
+
HMAP_FOR_EACH_IN_BUCKET (xport, hmap_node, hash_pointer(ofport, 0),
- &xports) {
+ xports) {
if (xport->ofport == ofport) {
return xport;
}
xport_stp_learn_state(const struct xport *xport)
{
struct stp_port *sp = xport_get_stp_port(xport);
- return stp_learn_in_state(sp ? stp_port_get_state(sp) : STP_DISABLED);
+ return sp
+ ? stp_learn_in_state(stp_port_get_state(sp))
+ : true;
}
static bool
xport_stp_forward_state(const struct xport *xport)
{
struct stp_port *sp = xport_get_stp_port(xport);
- return stp_forward_in_state(sp ? stp_port_get_state(sp) : STP_DISABLED);
+ return sp
+ ? stp_forward_in_state(stp_port_get_state(sp))
+ : true;
}
static bool
-xport_stp_listen_state(const struct xport *xport)
+xport_stp_should_forward_bpdu(const struct xport *xport)
{
struct stp_port *sp = xport_get_stp_port(xport);
- return stp_listen_in_state(sp ? stp_port_get_state(sp) : STP_DISABLED);
+ return stp_should_forward_bpdu(sp ? stp_port_get_state(sp) : STP_DISABLED);
}
/* Returns true if STP should process 'flow'. Sets fields in 'wc' that
static bool
stp_should_process_flow(const struct flow *flow, struct flow_wildcards *wc)
{
+ /* is_stp() also checks dl_type, but dl_type is always set in 'wc'. */
memset(&wc->masks.dl_dst, 0xff, sizeof wc->masks.dl_dst);
- return eth_addr_equals(flow->dl_dst, eth_addr_stp);
+ return is_stp(flow);
}
static void
{
struct stp_port *sp = xport_get_stp_port(xport);
struct ofpbuf payload = *packet;
- struct eth_header *eth = payload.data;
+ struct eth_header *eth = ofpbuf_data(&payload);
/* Sink packets on ports that have STP disabled when the bridge has
* STP enabled. */
}
/* Trim off padding on payload. */
- if (payload.size > ntohs(eth->eth_type) + ETH_HEADER_LEN) {
- payload.size = ntohs(eth->eth_type) + ETH_HEADER_LEN;
+ if (ofpbuf_size(&payload) > ntohs(eth->eth_type) + ETH_HEADER_LEN) {
+ ofpbuf_set_size(&payload, ntohs(eth->eth_type) + ETH_HEADER_LEN);
}
if (ofpbuf_try_pull(&payload, ETH_HEADER_LEN + LLC_HEADER_LEN)) {
- stp_received_bpdu(sp, payload.data, payload.size);
+ stp_received_bpdu(sp, ofpbuf_data(&payload), ofpbuf_size(&payload));
+ }
+}
+
+static enum rstp_state
+xport_get_rstp_port_state(const struct xport *xport)
+{
+ return xport->rstp_port
+ ? rstp_port_get_state(xport->rstp_port)
+ : RSTP_DISABLED;
+}
+
+static bool
+xport_rstp_learn_state(const struct xport *xport)
+{
+ return xport->xbridge->rstp && xport->rstp_port
+ ? rstp_learn_in_state(xport_get_rstp_port_state(xport))
+ : true;
+}
+
+static bool
+xport_rstp_forward_state(const struct xport *xport)
+{
+ return xport->xbridge->rstp && xport->rstp_port
+ ? rstp_forward_in_state(xport_get_rstp_port_state(xport))
+ : true;
+}
+
+static bool
+xport_rstp_should_manage_bpdu(const struct xport *xport)
+{
+ return rstp_should_manage_bpdu(xport_get_rstp_port_state(xport));
+}
+
+static void
+rstp_process_packet(const struct xport *xport, const struct ofpbuf *packet)
+{
+ struct ofpbuf payload = *packet;
+ struct eth_header *eth = ofpbuf_data(&payload);
+
+ /* Sink packets on ports that have no RSTP. */
+ if (!xport->rstp_port) {
+ return;
+ }
+
+ /* Trim off padding on payload. */
+ if (ofpbuf_size(&payload) > ntohs(eth->eth_type) + ETH_HEADER_LEN) {
+ ofpbuf_set_size(&payload, ntohs(eth->eth_type) + ETH_HEADER_LEN);
+ }
+
+ if (ofpbuf_try_pull(&payload, ETH_HEADER_LEN + LLC_HEADER_LEN)) {
+ rstp_port_received_bpdu(xport->rstp_port, ofpbuf_data(&payload),
+ ofpbuf_size(&payload));
}
}
static bool
odp_port_is_alive(const struct xlate_ctx *ctx, ofp_port_t ofp_port)
{
- struct xport *xport;
-
- xport = get_ofp_port(ctx->xbridge, ofp_port);
- if (!xport || xport->config & OFPUTIL_PC_PORT_DOWN ||
- xport->state & OFPUTIL_PS_LINK_DOWN) {
- return false;
- }
-
- return true;
+ struct xport *xport = get_ofp_port(ctx->xbridge, ofp_port);
+ return xport && xport->may_enable;
}
-static const struct ofputil_bucket *
+static struct ofputil_bucket *
group_first_live_bucket(const struct xlate_ctx *, const struct group_dpif *,
int depth);
group_is_alive(const struct xlate_ctx *ctx, uint32_t group_id, int depth)
{
struct group_dpif *group;
- bool hit;
- hit = group_dpif_lookup(ctx->xbridge->ofproto, group_id, &group);
- if (!hit) {
- return false;
- }
+ if (group_dpif_lookup(ctx->xbridge->ofproto, group_id, &group)) {
+ struct ofputil_bucket *bucket;
- hit = group_first_live_bucket(ctx, group, depth) != NULL;
+ bucket = group_first_live_bucket(ctx, group, depth);
+ group_dpif_unref(group);
+ return bucket == NULL;
+ }
- group_dpif_release(group);
- return hit;
+ return false;
}
#define MAX_LIVENESS_RECURSION 128 /* Arbitrary limit */
static bool
bucket_is_alive(const struct xlate_ctx *ctx,
- const struct ofputil_bucket *bucket, int depth)
+ struct ofputil_bucket *bucket, int depth)
{
if (depth >= MAX_LIVENESS_RECURSION) {
static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 1);
return false;
}
- return !ofputil_bucket_has_liveness(bucket) ||
- (bucket->watch_port != OFPP_ANY &&
- odp_port_is_alive(ctx, bucket->watch_port)) ||
- (bucket->watch_group != OFPG_ANY &&
- group_is_alive(ctx, bucket->watch_group, depth + 1));
+ return (!ofputil_bucket_has_liveness(bucket)
+ || (bucket->watch_port != OFPP_ANY
+ && odp_port_is_alive(ctx, bucket->watch_port))
+ || (bucket->watch_group != OFPG_ANY
+ && group_is_alive(ctx, bucket->watch_group, depth + 1)));
}
-static const struct ofputil_bucket *
+static struct ofputil_bucket *
group_first_live_bucket(const struct xlate_ctx *ctx,
const struct group_dpif *group, int depth)
{
return NULL;
}
-static const struct ofputil_bucket *
+static struct ofputil_bucket *
group_best_live_bucket(const struct xlate_ctx *ctx,
const struct group_dpif *group,
uint32_t basis)
{
- const struct ofputil_bucket *best_bucket = NULL;
+ struct ofputil_bucket *best_bucket = NULL;
uint32_t best_score = 0;
int i = 0;
- const struct ofputil_bucket *bucket;
+ struct ofputil_bucket *bucket;
const struct list *buckets;
group_dpif_get_buckets(group, &buckets);
return xport->xbundle;
}
- /* Special-case OFPP_NONE, which a controller may use as the ingress
- * port for traffic that it is sourcing. */
- if (in_port == OFPP_NONE) {
+ /* Special-case OFPP_NONE (OF1.0) and OFPP_CONTROLLER (OF1.1+),
+ * which a controller may use as the ingress port for traffic that
+ * it is sourcing. */
+ if (in_port == OFPP_CONTROLLER || in_port == OFPP_NONE) {
return &ofpp_none_bundle;
}
"%s, which is reserved exclusively for mirroring",
ctx->xbridge->name, in_xbundle->name);
}
- ofpbuf_clear(&ctx->xout->odp_actions);
+ ofpbuf_clear(ctx->xout->odp_actions);
return;
}
mirrors &= ~dup_mirrors;
ctx->xout->mirrors |= dup_mirrors;
if (out) {
- struct xbundle *out_xbundle = xbundle_lookup(out);
+ struct xlate_cfg *xcfg = ovsrcu_get(struct xlate_cfg *, &xcfgp);
+ struct xbundle *out_xbundle = xbundle_lookup(xcfg, out);
if (out_xbundle) {
output_normal(ctx, out_xbundle, vlan);
}
/* Partially configured bundle with no slaves. Drop the packet. */
return;
} else if (!out_xbundle->bond) {
+ ctx->use_recirc = false;
xport = CONTAINER_OF(list_front(&out_xbundle->xports), struct xport,
bundle_node);
} else {
+ struct xlate_cfg *xcfg = ovsrcu_get(struct xlate_cfg *, &xcfgp);
+ struct flow_wildcards *wc = &ctx->xout->wc;
+ struct xlate_recirc *xr = &ctx->recirc;
struct ofport_dpif *ofport;
- ofport = bond_choose_output_slave(out_xbundle->bond, &ctx->xin->flow,
- &ctx->xout->wc, vid);
- xport = xport_lookup(ofport);
+ if (ctx->xbridge->enable_recirc) {
+ ctx->use_recirc = bond_may_recirc(
+ out_xbundle->bond, &xr->recirc_id, &xr->hash_basis);
+
+ if (ctx->use_recirc) {
+ /* Only TCP mode uses recirculation. */
+ xr->hash_alg = OVS_HASH_ALG_L4;
+ bond_update_post_recirc_rules(out_xbundle->bond, false);
+
+ /* Recirculation does not require unmasking hash fields. */
+ wc = NULL;
+ }
+ }
+
+ ofport = bond_choose_output_slave(out_xbundle->bond,
+ &ctx->xin->flow, wc, vid);
+ xport = xport_lookup(xcfg, ofport);
if (!xport) {
/* No slaves enabled, so drop packet. */
return;
}
- if (ctx->xin->resubmit_stats) {
- bond_account(out_xbundle->bond, &ctx->xin->flow, vid,
- ctx->xin->resubmit_stats->n_bytes);
+ /* If ctx->xout->use_recirc is set, the main thread will handle stats
+ * accounting for this bond. */
+ if (!ctx->use_recirc) {
+ if (ctx->xin->resubmit_stats) {
+ bond_account(out_xbundle->bond, &ctx->xin->flow, vid,
+ ctx->xin->resubmit_stats->n_bytes);
+ }
+ if (ctx->xin->xcache) {
+ struct xc_entry *entry;
+ struct flow *flow;
+
+ flow = &ctx->xin->flow;
+ entry = xlate_cache_add_entry(ctx->xin->xcache, XC_BOND);
+ entry->u.bond.bond = bond_ref(out_xbundle->bond);
+ entry->u.bond.flow = xmemdup(flow, sizeof *flow);
+ entry->u.bond.vid = vid;
+ }
}
}
return false;
}
- memset(&wc->masks.dl_dst, 0xff, sizeof wc->masks.dl_dst);
- if (!eth_addr_is_broadcast(flow->dl_dst)) {
+ memset(&wc->masks.dl_dst, 0xff, sizeof wc->masks.dl_dst);
+ if (!eth_addr_is_broadcast(flow->dl_dst)) {
+ return false;
+ }
+
+ memset(&wc->masks.nw_proto, 0xff, sizeof wc->masks.nw_proto);
+ if (flow->nw_proto == ARP_OP_REPLY) {
+ return true;
+ } else if (flow->nw_proto == ARP_OP_REQUEST) {
+ memset(&wc->masks.nw_src, 0xff, sizeof wc->masks.nw_src);
+ memset(&wc->masks.nw_dst, 0xff, sizeof wc->masks.nw_dst);
+
+ return flow->nw_src == flow->nw_dst;
+ } else {
+ return false;
+ }
+}
+
+/* Determines whether packets in 'flow' within 'xbridge' should be forwarded or
+ * dropped. Returns true if they may be forwarded, false if they should be
+ * dropped.
+ *
+ * 'in_port' must be the xport that corresponds to flow->in_port.
+ * 'in_port' must be part of a bundle (e.g. in_port->bundle must be nonnull).
+ *
+ * 'vlan' must be the VLAN that corresponds to flow->vlan_tci on 'in_port', as
+ * returned by input_vid_to_vlan(). It must be a valid VLAN for 'in_port', as
+ * checked by input_vid_is_valid().
+ *
+ * May also add tags to '*tags', although the current implementation only does
+ * so in one special case.
+ */
+static bool
+is_admissible(struct xlate_ctx *ctx, struct xport *in_port,
+ uint16_t vlan)
+{
+ struct xbundle *in_xbundle = in_port->xbundle;
+ const struct xbridge *xbridge = ctx->xbridge;
+ struct flow *flow = &ctx->xin->flow;
+
+ /* Drop frames for reserved multicast addresses
+ * only if forward_bpdu option is absent. */
+ if (!xbridge->forward_bpdu && eth_addr_is_reserved(flow->dl_dst)) {
+ xlate_report(ctx, "packet has reserved destination MAC, dropping");
return false;
}
- memset(&wc->masks.nw_proto, 0xff, sizeof wc->masks.nw_proto);
- if (flow->nw_proto == ARP_OP_REPLY) {
- return true;
- } else if (flow->nw_proto == ARP_OP_REQUEST) {
- memset(&wc->masks.nw_src, 0xff, sizeof wc->masks.nw_src);
- memset(&wc->masks.nw_dst, 0xff, sizeof wc->masks.nw_dst);
+ if (in_xbundle->bond) {
+ struct mac_entry *mac;
- return flow->nw_src == flow->nw_dst;
- } else {
- return false;
+ switch (bond_check_admissibility(in_xbundle->bond, in_port->ofport,
+ flow->dl_dst)) {
+ case BV_ACCEPT:
+ break;
+
+ case BV_DROP:
+ xlate_report(ctx, "bonding refused admissibility, dropping");
+ return false;
+
+ case BV_DROP_IF_MOVED:
+ ovs_rwlock_rdlock(&xbridge->ml->rwlock);
+ mac = mac_learning_lookup(xbridge->ml, flow->dl_src, vlan);
+ if (mac && mac->port.p != in_xbundle->ofbundle &&
+ (!is_gratuitous_arp(flow, &ctx->xout->wc)
+ || mac_entry_is_grat_arp_locked(mac))) {
+ ovs_rwlock_unlock(&xbridge->ml->rwlock);
+ xlate_report(ctx, "SLB bond thinks this packet looped back, "
+ "dropping");
+ return false;
+ }
+ ovs_rwlock_unlock(&xbridge->ml->rwlock);
+ break;
+ }
}
+
+ return true;
}
/* Checks whether a MAC learning update is necessary for MAC learning table
}
}
-/* Determines whether packets in 'flow' within 'xbridge' should be forwarded or
- * dropped. Returns true if they may be forwarded, false if they should be
- * dropped.
- *
- * 'in_port' must be the xport that corresponds to flow->in_port.
- * 'in_port' must be part of a bundle (e.g. in_port->bundle must be nonnull).
- *
- * 'vlan' must be the VLAN that corresponds to flow->vlan_tci on 'in_port', as
- * returned by input_vid_to_vlan(). It must be a valid VLAN for 'in_port', as
- * checked by input_vid_is_valid().
- *
- * May also add tags to '*tags', although the current implementation only does
- * so in one special case.
- */
-static bool
-is_admissible(struct xlate_ctx *ctx, struct xport *in_port,
- uint16_t vlan)
+/* Updates multicast snooping table 'ms' given that a packet matching 'flow'
+ * was received on 'in_xbundle' in 'vlan' and is either Report or Query. */
+static void
+update_mcast_snooping_table__(const struct xbridge *xbridge,
+ const struct flow *flow,
+ struct mcast_snooping *ms,
+ ovs_be32 ip4, int vlan,
+ struct xbundle *in_xbundle)
+ OVS_REQ_WRLOCK(ms->rwlock)
{
- struct xbundle *in_xbundle = in_port->xbundle;
- const struct xbridge *xbridge = ctx->xbridge;
- struct flow *flow = &ctx->xin->flow;
-
- /* Drop frames for reserved multicast addresses
- * only if forward_bpdu option is absent. */
- if (!xbridge->forward_bpdu && eth_addr_is_reserved(flow->dl_dst)) {
- xlate_report(ctx, "packet has reserved destination MAC, dropping");
- return false;
+ static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(60, 30);
+
+ switch (ntohs(flow->tp_src)) {
+ case IGMP_HOST_MEMBERSHIP_REPORT:
+ case IGMPV2_HOST_MEMBERSHIP_REPORT:
+ if (mcast_snooping_add_group(ms, ip4, vlan, in_xbundle->ofbundle)) {
+ VLOG_DBG_RL(&rl, "bridge %s: multicast snooping learned that "
+ IP_FMT" is on port %s in VLAN %d",
+ xbridge->name, IP_ARGS(ip4), in_xbundle->name, vlan);
+ }
+ break;
+ case IGMP_HOST_LEAVE_MESSAGE:
+ if (mcast_snooping_leave_group(ms, ip4, vlan, in_xbundle->ofbundle)) {
+ VLOG_DBG_RL(&rl, "bridge %s: multicast snooping leaving "
+ IP_FMT" is on port %s in VLAN %d",
+ xbridge->name, IP_ARGS(ip4), in_xbundle->name, vlan);
+ }
+ break;
+ case IGMP_HOST_MEMBERSHIP_QUERY:
+ if (flow->nw_src && mcast_snooping_add_mrouter(ms, vlan,
+ in_xbundle->ofbundle)) {
+ VLOG_DBG_RL(&rl, "bridge %s: multicast snooping query from "
+ IP_FMT" is on port %s in VLAN %d",
+ xbridge->name, IP_ARGS(flow->nw_src),
+ in_xbundle->name, vlan);
+ }
+ break;
}
+}
- if (in_xbundle->bond) {
- struct mac_entry *mac;
+/* Updates multicast snooping table 'ms' given that a packet matching 'flow'
+ * was received on 'in_xbundle' in 'vlan'. */
+static void
+update_mcast_snooping_table(const struct xbridge *xbridge,
+ const struct flow *flow, int vlan,
+ struct xbundle *in_xbundle)
+{
+ struct mcast_snooping *ms = xbridge->ms;
+ struct xlate_cfg *xcfg;
+ struct xbundle *mcast_xbundle;
+ struct mcast_fport_bundle *fport;
- switch (bond_check_admissibility(in_xbundle->bond, in_port->ofport,
- flow->dl_dst)) {
- case BV_ACCEPT:
+ /* Don't learn the OFPP_NONE port. */
+ if (in_xbundle == &ofpp_none_bundle) {
+ return;
+ }
+
+ /* Don't learn from flood ports */
+ mcast_xbundle = NULL;
+ ovs_rwlock_wrlock(&ms->rwlock);
+ xcfg = ovsrcu_get(struct xlate_cfg *, &xcfgp);
+ LIST_FOR_EACH(fport, fport_node, &ms->fport_list) {
+ mcast_xbundle = xbundle_lookup(xcfg, fport->port);
+ if (mcast_xbundle == in_xbundle) {
break;
+ }
+ }
- case BV_DROP:
- xlate_report(ctx, "bonding refused admissibility, dropping");
- return false;
+ if (!mcast_xbundle || mcast_xbundle != in_xbundle) {
+ update_mcast_snooping_table__(xbridge, flow, ms, flow->igmp_group_ip4,
+ vlan, in_xbundle);
+ }
+ ovs_rwlock_unlock(&ms->rwlock);
+}
- case BV_DROP_IF_MOVED:
- ovs_rwlock_rdlock(&xbridge->ml->rwlock);
- mac = mac_learning_lookup(xbridge->ml, flow->dl_src, vlan);
- if (mac && mac->port.p != in_xbundle->ofbundle &&
- (!is_gratuitous_arp(flow, &ctx->xout->wc)
- || mac_entry_is_grat_arp_locked(mac))) {
- ovs_rwlock_unlock(&xbridge->ml->rwlock);
- xlate_report(ctx, "SLB bond thinks this packet looped back, "
- "dropping");
- return false;
- }
- ovs_rwlock_unlock(&xbridge->ml->rwlock);
- break;
+/* send the packet to ports having the multicast group learned */
+static void
+xlate_normal_mcast_send_group(struct xlate_ctx *ctx,
+ struct mcast_snooping *ms OVS_UNUSED,
+ struct mcast_group *grp,
+ struct xbundle *in_xbundle, uint16_t vlan)
+ OVS_REQ_RDLOCK(ms->rwlock)
+{
+ struct xlate_cfg *xcfg;
+ struct mcast_group_bundle *b;
+ struct xbundle *mcast_xbundle;
+
+ xcfg = ovsrcu_get(struct xlate_cfg *, &xcfgp);
+ LIST_FOR_EACH(b, bundle_node, &grp->bundle_lru) {
+ mcast_xbundle = xbundle_lookup(xcfg, b->port);
+ if (mcast_xbundle && mcast_xbundle != in_xbundle) {
+ xlate_report(ctx, "forwarding to mcast group port");
+ output_normal(ctx, mcast_xbundle, vlan);
+ } else if (!mcast_xbundle) {
+ xlate_report(ctx, "mcast group port is unknown, dropping");
+ } else {
+ xlate_report(ctx, "mcast group port is input port, dropping");
}
}
+}
- return true;
+/* send the packet to ports connected to multicast routers */
+static void
+xlate_normal_mcast_send_mrouters(struct xlate_ctx *ctx,
+ struct mcast_snooping *ms,
+ struct xbundle *in_xbundle, uint16_t vlan)
+ OVS_REQ_RDLOCK(ms->rwlock)
+{
+ struct xlate_cfg *xcfg;
+ struct mcast_mrouter_bundle *mrouter;
+ struct xbundle *mcast_xbundle;
+
+ xcfg = ovsrcu_get(struct xlate_cfg *, &xcfgp);
+ LIST_FOR_EACH(mrouter, mrouter_node, &ms->mrouter_lru) {
+ mcast_xbundle = xbundle_lookup(xcfg, mrouter->port);
+ if (mcast_xbundle && mcast_xbundle != in_xbundle) {
+ xlate_report(ctx, "forwarding to mcast router port");
+ output_normal(ctx, mcast_xbundle, vlan);
+ } else if (!mcast_xbundle) {
+ xlate_report(ctx, "mcast router port is unknown, dropping");
+ } else {
+ xlate_report(ctx, "mcast router port is input port, dropping");
+ }
+ }
+}
+
+/* send the packet to ports flagged to be flooded */
+static void
+xlate_normal_mcast_send_fports(struct xlate_ctx *ctx,
+ struct mcast_snooping *ms,
+ struct xbundle *in_xbundle, uint16_t vlan)
+ OVS_REQ_RDLOCK(ms->rwlock)
+{
+ struct xlate_cfg *xcfg;
+ struct mcast_fport_bundle *fport;
+ struct xbundle *mcast_xbundle;
+
+ xcfg = ovsrcu_get(struct xlate_cfg *, &xcfgp);
+ LIST_FOR_EACH(fport, fport_node, &ms->fport_list) {
+ mcast_xbundle = xbundle_lookup(xcfg, fport->port);
+ if (mcast_xbundle && mcast_xbundle != in_xbundle) {
+ xlate_report(ctx, "forwarding to mcast flood port");
+ output_normal(ctx, mcast_xbundle, vlan);
+ } else if (!mcast_xbundle) {
+ xlate_report(ctx, "mcast flood port is unknown, dropping");
+ } else {
+ xlate_report(ctx, "mcast flood port is input port, dropping");
+ }
+ }
+}
+
+static void
+xlate_normal_flood(struct xlate_ctx *ctx, struct xbundle *in_xbundle,
+ uint16_t vlan)
+{
+ struct xbundle *xbundle;
+
+ LIST_FOR_EACH (xbundle, list_node, &ctx->xbridge->xbundles) {
+ if (xbundle != in_xbundle
+ && xbundle_includes_vlan(xbundle, vlan)
+ && xbundle->floodable
+ && !xbundle_mirror_out(ctx->xbridge, xbundle)) {
+ output_normal(ctx, xbundle, vlan);
+ }
+ }
+ ctx->xout->nf_output_iface = NF_OUT_FLOOD;
}
static void
if (ctx->xin->may_learn) {
update_learning_table(ctx->xbridge, flow, wc, vlan, in_xbundle);
}
+ if (ctx->xin->xcache) {
+ struct xc_entry *entry;
+
+ /* Save enough info to update mac learning table later. */
+ entry = xlate_cache_add_entry(ctx->xin->xcache, XC_NORMAL);
+ entry->u.normal.ofproto = ctx->xbridge->ofproto;
+ entry->u.normal.flow = xmemdup(flow, sizeof *flow);
+ entry->u.normal.vlan = vlan;
+ }
/* Determine output bundle. */
- ovs_rwlock_rdlock(&ctx->xbridge->ml->rwlock);
- mac = mac_learning_lookup(ctx->xbridge->ml, flow->dl_dst, vlan);
- mac_port = mac ? mac->port.p : NULL;
- ovs_rwlock_unlock(&ctx->xbridge->ml->rwlock);
-
- if (mac_port) {
- struct xbundle *mac_xbundle = xbundle_lookup(mac_port);
- if (mac_xbundle && mac_xbundle != in_xbundle) {
- xlate_report(ctx, "forwarding to learned port");
- output_normal(ctx, mac_xbundle, vlan);
- } else if (!mac_xbundle) {
- xlate_report(ctx, "learned port is unknown, dropping");
+ if (mcast_snooping_enabled(ctx->xbridge->ms)
+ && !eth_addr_is_broadcast(flow->dl_dst)
+ && eth_addr_is_multicast(flow->dl_dst)
+ && flow->dl_type == htons(ETH_TYPE_IP)) {
+ struct mcast_snooping *ms = ctx->xbridge->ms;
+ struct mcast_group *grp;
+
+ if (flow->nw_proto == IPPROTO_IGMP) {
+ if (ctx->xin->may_learn) {
+ if (mcast_snooping_is_membership(flow->tp_src) ||
+ mcast_snooping_is_query(flow->tp_src)) {
+ update_mcast_snooping_table(ctx->xbridge, flow, vlan,
+ in_xbundle);
+ }
+ }
+
+ if (mcast_snooping_is_membership(flow->tp_src)) {
+ ovs_rwlock_rdlock(&ms->rwlock);
+ xlate_normal_mcast_send_mrouters(ctx, ms, in_xbundle, vlan);
+ ovs_rwlock_unlock(&ms->rwlock);
+ } else {
+ xlate_report(ctx, "multicast traffic, flooding");
+ xlate_normal_flood(ctx, in_xbundle, vlan);
+ }
+ return;
+ } else {
+ if (ip_is_local_multicast(flow->nw_dst)) {
+ /* RFC4541: section 2.1.2, item 2: Packets with a dst IP
+ * address in the 224.0.0.x range which are not IGMP must
+ * be forwarded on all ports */
+ xlate_report(ctx, "RFC4541: section 2.1.2, item 2, flooding");
+ xlate_normal_flood(ctx, in_xbundle, vlan);
+ return;
+ }
+ }
+
+ /* forwarding to group base ports */
+ ovs_rwlock_rdlock(&ms->rwlock);
+ grp = mcast_snooping_lookup(ms, flow->nw_dst, vlan);
+ if (grp) {
+ xlate_normal_mcast_send_group(ctx, ms, grp, in_xbundle, vlan);
+ xlate_normal_mcast_send_fports(ctx, ms, in_xbundle, vlan);
+ xlate_normal_mcast_send_mrouters(ctx, ms, in_xbundle, vlan);
} else {
- xlate_report(ctx, "learned port is input port, dropping");
+ if (mcast_snooping_flood_unreg(ms)) {
+ xlate_report(ctx, "unregistered multicast, flooding");
+ xlate_normal_flood(ctx, in_xbundle, vlan);
+ } else {
+ xlate_normal_mcast_send_mrouters(ctx, ms, in_xbundle, vlan);
+ xlate_normal_mcast_send_fports(ctx, ms, in_xbundle, vlan);
+ }
}
+ ovs_rwlock_unlock(&ms->rwlock);
} else {
- struct xbundle *xbundle;
-
- xlate_report(ctx, "no learned MAC for destination, flooding");
- LIST_FOR_EACH (xbundle, list_node, &ctx->xbridge->xbundles) {
- if (xbundle != in_xbundle
- && xbundle_includes_vlan(xbundle, vlan)
- && xbundle->floodable
- && !xbundle_mirror_out(ctx->xbridge, xbundle)) {
- output_normal(ctx, xbundle, vlan);
+ ovs_rwlock_rdlock(&ctx->xbridge->ml->rwlock);
+ mac = mac_learning_lookup(ctx->xbridge->ml, flow->dl_dst, vlan);
+ mac_port = mac ? mac->port.p : NULL;
+ ovs_rwlock_unlock(&ctx->xbridge->ml->rwlock);
+
+ if (mac_port) {
+ struct xlate_cfg *xcfg = ovsrcu_get(struct xlate_cfg *, &xcfgp);
+ struct xbundle *mac_xbundle = xbundle_lookup(xcfg, mac_port);
+ if (mac_xbundle && mac_xbundle != in_xbundle) {
+ xlate_report(ctx, "forwarding to learned port");
+ output_normal(ctx, mac_xbundle, vlan);
+ } else if (!mac_xbundle) {
+ xlate_report(ctx, "learned port is unknown, dropping");
+ } else {
+ xlate_report(ctx, "learned port is input port, dropping");
}
+ } else {
+ xlate_report(ctx, "no learned MAC for destination, flooding");
+ xlate_normal_flood(ctx, in_xbundle, vlan);
}
- ctx->xout->nf_output_iface = NF_OUT_FLOOD;
}
}
const struct flow *flow,
const uint32_t probability,
const union user_action_cookie *cookie,
- const size_t cookie_size)
+ const size_t cookie_size,
+ const odp_port_t tunnel_out_port)
{
size_t sample_offset, actions_offset;
odp_port_t odp_port;
actions_offset = nl_msg_start_nested(odp_actions, OVS_SAMPLE_ATTR_ACTIONS);
odp_port = ofp_port_to_odp_port(xbridge, flow->in_port.ofp_port);
- pid = dpif_port_get_pid(xbridge->dpif, odp_port, 0);
- cookie_offset = odp_put_userspace_action(pid, cookie, cookie_size, odp_actions);
+ pid = dpif_port_get_pid(xbridge->dpif, odp_port,
+ flow_hash_5tuple(flow, 0));
+ cookie_offset = odp_put_userspace_action(pid, cookie, cookie_size,
+ tunnel_out_port, odp_actions);
nl_msg_end_nested(odp_actions, actions_offset);
nl_msg_end_nested(odp_actions, sample_offset);
odp_port == ODPP_NONE ? 0 : 1, &cookie);
return compose_sample_action(xbridge, odp_actions, flow, probability,
- &cookie, sizeof cookie.sflow);
+ &cookie, sizeof cookie.sflow, ODPP_NONE);
}
static void
}
static void
-compose_ipfix_cookie(union user_action_cookie *cookie)
+compose_ipfix_cookie(union user_action_cookie *cookie,
+ odp_port_t output_odp_port)
{
cookie->type = USER_ACTION_COOKIE_IPFIX;
+ cookie->ipfix.output_odp_port = output_odp_port;
}
/* Compose SAMPLE action for IPFIX bridge sampling. */
static void
compose_ipfix_action(const struct xbridge *xbridge,
struct ofpbuf *odp_actions,
- const struct flow *flow)
+ const struct flow *flow,
+ odp_port_t output_odp_port)
{
uint32_t probability;
union user_action_cookie cookie;
+ odp_port_t tunnel_out_port = ODPP_NONE;
if (!xbridge->ipfix || flow->in_port.ofp_port == OFPP_NONE) {
return;
}
+ /* For input case, output_odp_port is ODPP_NONE, which is an invalid port
+ * number. */
+ if (output_odp_port == ODPP_NONE &&
+ !dpif_ipfix_get_bridge_exporter_input_sampling(xbridge->ipfix)) {
+ return;
+ }
+
+ /* For output case, output_odp_port is valid*/
+ if (output_odp_port != ODPP_NONE) {
+ if (!dpif_ipfix_get_bridge_exporter_output_sampling(xbridge->ipfix)) {
+ return;
+ }
+ /* If tunnel sampling is enabled, put an additional option attribute:
+ * OVS_USERSPACE_ATTR_TUNNEL_OUT_PORT
+ */
+ if (dpif_ipfix_get_bridge_exporter_tunnel_sampling(xbridge->ipfix) &&
+ dpif_ipfix_get_tunnel_port(xbridge->ipfix, output_odp_port) ) {
+ tunnel_out_port = output_odp_port;
+ }
+ }
+
probability = dpif_ipfix_get_bridge_exporter_probability(xbridge->ipfix);
- compose_ipfix_cookie(&cookie);
+ compose_ipfix_cookie(&cookie, output_odp_port);
compose_sample_action(xbridge, odp_actions, flow, probability,
- &cookie, sizeof cookie.ipfix);
+ &cookie, sizeof cookie.ipfix, tunnel_out_port);
}
/* SAMPLE action for sFlow must be first action in any given list of
add_sflow_action(struct xlate_ctx *ctx)
{
ctx->user_cookie_offset = compose_sflow_action(ctx->xbridge,
- &ctx->xout->odp_actions,
+ ctx->xout->odp_actions,
&ctx->xin->flow, ODPP_NONE);
ctx->sflow_odp_port = 0;
ctx->sflow_n_outputs = 0;
static void
add_ipfix_action(struct xlate_ctx *ctx)
{
- compose_ipfix_action(ctx->xbridge, &ctx->xout->odp_actions,
- &ctx->xin->flow);
+ compose_ipfix_action(ctx->xbridge, ctx->xout->odp_actions,
+ &ctx->xin->flow, ODPP_NONE);
+}
+
+static void
+add_ipfix_output_action(struct xlate_ctx *ctx, odp_port_t port)
+{
+ compose_ipfix_action(ctx->xbridge, ctx->xout->odp_actions,
+ &ctx->xin->flow, port);
}
/* Fix SAMPLE action according to data collected while composing ODP actions.
return;
}
- cookie = ofpbuf_at(&ctx->xout->odp_actions, ctx->user_cookie_offset,
+ cookie = ofpbuf_at(ctx->xout->odp_actions, ctx->user_cookie_offset,
sizeof cookie->sflow);
ovs_assert(cookie->type == USER_ACTION_COOKIE_SFLOW);
bfd_process_packet(xport->bfd, flow, packet);
/* If POLL received, immediately sends FINAL back. */
if (bfd_should_send_packet(xport->bfd)) {
- if (xport->peer) {
- ofproto_dpif_monitor_port_send_soon(xport->ofport);
- } else {
- ofproto_dpif_monitor_port_send_soon_safe(xport->ofport);
- }
+ ofproto_dpif_monitor_port_send_soon(xport->ofport);
}
}
return SLOW_BFD;
lacp_process_packet(xport->xbundle->lacp, xport->ofport, packet);
}
return SLOW_LACP;
- } else if (xbridge->stp && stp_should_process_flow(flow, wc)) {
+ } else if ((xbridge->stp || xbridge->rstp) &&
+ stp_should_process_flow(flow, wc)) {
if (packet) {
- stp_process_packet(xport, packet);
+ xbridge->stp
+ ? stp_process_packet(xport, packet)
+ : rstp_process_packet(xport, packet);
}
return SLOW_STP;
} else {
}
}
+static int
+tnl_route_lookup_flow(const struct flow *oflow,
+ ovs_be32 *ip, struct xport **out_port)
+{
+ char out_dev[IFNAMSIZ];
+ struct xbridge *xbridge;
+ struct xlate_cfg *xcfg;
+ ovs_be32 gw;
+
+ if (!ovs_router_lookup(oflow->tunnel.ip_dst, out_dev, &gw)) {
+ return -ENOENT;
+ }
+
+ if (gw) {
+ *ip = gw;
+ } else {
+ *ip = oflow->tunnel.ip_dst;
+ }
+
+ xcfg = ovsrcu_get(struct xlate_cfg *, &xcfgp);
+ ovs_assert(xcfg);
+
+ HMAP_FOR_EACH (xbridge, hmap_node, &xcfg->xbridges) {
+ if (!strncmp(xbridge->name, out_dev, IFNAMSIZ)) {
+ struct xport *port;
+
+ HMAP_FOR_EACH (port, ofp_node, &xbridge->xports) {
+ if (!strncmp(netdev_get_name(port->netdev), out_dev, IFNAMSIZ)) {
+ *out_port = port;
+ return 0;
+ }
+ }
+ }
+ }
+ return -ENOENT;
+}
+
+static int
+xlate_flood_packet(struct xbridge *xbridge, struct ofpbuf *packet)
+{
+ struct ofpact_output output;
+ struct flow flow;
+
+ ofpact_init(&output.ofpact, OFPACT_OUTPUT, sizeof output);
+ /* Use OFPP_NONE as the in_port to avoid special packet processing. */
+ flow_extract(packet, NULL, &flow);
+ flow.in_port.ofp_port = OFPP_NONE;
+ output.port = OFPP_FLOOD;
+ output.max_len = 0;
+
+ return ofproto_dpif_execute_actions(xbridge->ofproto, &flow, NULL,
+ &output.ofpact, sizeof output,
+ packet);
+}
+
+static void
+tnl_send_arp_request(const struct xport *out_dev, const uint8_t eth_src[ETH_ADDR_LEN],
+ ovs_be32 ip_src, ovs_be32 ip_dst)
+{
+ struct xbridge *xbridge = out_dev->xbridge;
+ struct ofpbuf packet;
+
+ ofpbuf_init(&packet, 0);
+ compose_arp(&packet, eth_src, ip_src, ip_dst);
+
+ xlate_flood_packet(xbridge, &packet);
+ ofpbuf_uninit(&packet);
+}
+
+static int
+build_tunnel_send(const struct xlate_ctx *ctx, const struct xport *xport,
+ const struct flow *flow, odp_port_t tunnel_odp_port)
+{
+ struct ovs_action_push_tnl tnl_push_data;
+ struct xport *out_dev = NULL;
+ ovs_be32 s_ip, d_ip = 0;
+ uint8_t smac[ETH_ADDR_LEN];
+ uint8_t dmac[ETH_ADDR_LEN];
+ int err;
+
+ err = tnl_route_lookup_flow(flow, &d_ip, &out_dev);
+ if (err) {
+ return err;
+ }
+
+ /* Use mac addr of bridge port of the peer. */
+ err = netdev_get_etheraddr(out_dev->netdev, smac);
+ if (err) {
+ return err;
+ }
+
+ err = netdev_get_in4(out_dev->netdev, (struct in_addr *) &s_ip, NULL);
+ if (err) {
+ return err;
+ }
+
+ err = tnl_arp_lookup(out_dev->xbridge->name, d_ip, dmac);
+ if (err) {
+ tnl_send_arp_request(out_dev, smac, s_ip, d_ip);
+ return err;
+ }
+ if (ctx->xin->xcache) {
+ struct xc_entry *entry;
+
+ entry = xlate_cache_add_entry(ctx->xin->xcache, XC_TNL_ARP);
+ strncpy(entry->u.tnl_arp_cache.br_name, out_dev->xbridge->name, IFNAMSIZ);
+ entry->u.tnl_arp_cache.d_ip = d_ip;
+ }
+ err = tnl_port_build_header(xport->ofport, flow,
+ dmac, smac, s_ip, &tnl_push_data);
+ if (err) {
+ return err;
+ }
+ tnl_push_data.tnl_port = odp_to_u32(tunnel_odp_port);
+ tnl_push_data.out_port = odp_to_u32(out_dev->odp_port);
+ odp_put_tnl_push_action(ctx->xout->odp_actions, &tnl_push_data);
+ return 0;
+}
+
static void
compose_output_action__(struct xlate_ctx *ctx, ofp_port_t ofp_port,
bool check_stp)
const struct xport *xport = get_ofp_port(ctx->xbridge, ofp_port);
struct flow_wildcards *wc = &ctx->xout->wc;
struct flow *flow = &ctx->xin->flow;
+ struct flow_tnl flow_tnl;
ovs_be16 flow_vlan_tci;
uint32_t flow_pkt_mark;
uint8_t flow_nw_tos;
odp_port_t out_port, odp_port;
+ bool tnl_push_pop_send = false;
uint8_t dscp;
/* If 'struct flow' gets additional metadata, we'll need to zero it out
* before traversing a patch port. */
- BUILD_ASSERT_DECL(FLOW_WC_SEQ == 24);
+ BUILD_ASSERT_DECL(FLOW_WC_SEQ == 28);
+ memset(&flow_tnl, 0, sizeof flow_tnl);
if (!xport) {
xlate_report(ctx, "Nonexistent output port");
xlate_report(ctx, "OFPPC_NO_FWD set, skipping output");
return;
} else if (check_stp) {
- if (eth_addr_equals(ctx->base_flow.dl_dst, eth_addr_stp)) {
- if (!xport_stp_listen_state(xport)) {
- xlate_report(ctx, "STP not in listening state, "
- "skipping bpdu output");
+ if (is_stp(&ctx->base_flow)) {
+ if (!xport_stp_should_forward_bpdu(xport) &&
+ !xport_rstp_should_manage_bpdu(xport)) {
+ if (ctx->xbridge->stp != NULL) {
+ xlate_report(ctx, "STP not in listening state, "
+ "skipping bpdu output");
+ } else if (ctx->xbridge->rstp != NULL) {
+ xlate_report(ctx, "RSTP not managing BPDU in this state, "
+ "skipping bpdu output");
+ }
return;
}
- } else if (!xport_stp_forward_state(xport)) {
- xlate_report(ctx, "STP not in forwarding state, "
- "skipping output");
+ } else if (!xport_stp_forward_state(xport) ||
+ !xport_rstp_forward_state(xport)) {
+ if (ctx->xbridge->stp != NULL) {
+ xlate_report(ctx, "STP not in forwarding state, "
+ "skipping output");
+ } else if (ctx->xbridge->rstp != NULL) {
+ xlate_report(ctx, "RSTP not in forwarding state, "
+ "skipping output");
+ }
return;
}
}
const struct xport *peer = xport->peer;
struct flow old_flow = ctx->xin->flow;
enum slow_path_reason special;
+ uint8_t table_id = rule_dpif_lookup_get_init_table_id(&ctx->xin->flow);
ctx->xbridge = peer->xbridge;
flow->in_port.ofp_port = peer->ofp_port;
flow->metadata = htonll(0);
memset(&flow->tunnel, 0, sizeof flow->tunnel);
memset(flow->regs, 0, sizeof flow->regs);
+ flow->actset_output = OFPP_UNSET;
special = process_special(ctx, &ctx->xin->flow, peer,
ctx->xin->packet);
if (special) {
ctx->xout->slow |= special;
} else if (may_receive(peer, ctx)) {
- if (xport_stp_forward_state(peer)) {
- xlate_table_action(ctx, flow->in_port.ofp_port, 0, true, true);
+ if (xport_stp_forward_state(peer) && xport_rstp_forward_state(peer)) {
+ xlate_table_action(ctx, flow->in_port.ofp_port, table_id,
+ true, true);
} else {
- /* Forwarding is disabled by STP. Let OFPP_NORMAL and the
- * learning action look at the packet, then drop it. */
+ /* Forwarding is disabled by STP and RSTP. Let OFPP_NORMAL and
+ * the learning action look at the packet, then drop it. */
struct flow old_base_flow = ctx->base_flow;
- size_t old_size = ctx->xout->odp_actions.size;
+ size_t old_size = ofpbuf_size(ctx->xout->odp_actions);
mirror_mask_t old_mirrors = ctx->xout->mirrors;
- xlate_table_action(ctx, flow->in_port.ofp_port, 0, true, true);
+ xlate_table_action(ctx, flow->in_port.ofp_port, table_id,
+ true, true);
ctx->xout->mirrors = old_mirrors;
ctx->base_flow = old_base_flow;
- ctx->xout->odp_actions.size = old_size;
+ ofpbuf_set_size(ctx->xout->odp_actions, old_size);
}
}
bfd_account_rx(peer->bfd, ctx->xin->resubmit_stats);
}
}
+ if (ctx->xin->xcache) {
+ struct xc_entry *entry;
+ entry = xlate_cache_add_entry(ctx->xin->xcache, XC_NETDEV);
+ entry->u.dev.tx = netdev_ref(xport->netdev);
+ entry->u.dev.rx = netdev_ref(peer->netdev);
+ entry->u.dev.bfd = bfd_ref(peer->bfd);
+ }
return;
}
flow_pkt_mark = flow->pkt_mark;
flow_nw_tos = flow->nw_tos;
- if (dscp_from_skb_priority(xport, flow->skb_priority, &dscp)) {
- wc->masks.nw_tos |= IP_ECN_MASK;
- flow->nw_tos &= ~IP_DSCP_MASK;
- flow->nw_tos |= dscp;
+ if (count_skb_priorities(xport)) {
+ memset(&wc->masks.skb_priority, 0xff, sizeof wc->masks.skb_priority);
+ if (dscp_from_skb_priority(xport, flow->skb_priority, &dscp)) {
+ wc->masks.nw_tos |= IP_DSCP_MASK;
+ flow->nw_tos &= ~IP_DSCP_MASK;
+ flow->nw_tos |= dscp;
+ }
}
if (xport->is_tunnel) {
* the Logical (tunnel) Port are not visible for any further
* matches, while explicit set actions on tunnel metadata are.
*/
- struct flow_tnl flow_tnl = flow->tunnel;
+ flow_tnl = flow->tunnel;
odp_port = tnl_port_send(xport->ofport, flow, &ctx->xout->wc);
if (odp_port == ODPP_NONE) {
xlate_report(ctx, "Tunneling decided against output");
if (ctx->xin->resubmit_stats) {
netdev_vport_inc_tx(xport->netdev, ctx->xin->resubmit_stats);
}
+ if (ctx->xin->xcache) {
+ struct xc_entry *entry;
+
+ entry = xlate_cache_add_entry(ctx->xin->xcache, XC_NETDEV);
+ entry->u.dev.tx = netdev_ref(xport->netdev);
+ }
out_port = odp_port;
- commit_odp_tunnel_action(flow, &ctx->base_flow,
- &ctx->xout->odp_actions);
- flow->tunnel = flow_tnl; /* Restore tunnel metadata */
+ if (ovs_native_tunneling_is_on(ctx->xbridge->ofproto)) {
+ tnl_push_pop_send = true;
+ } else {
+ commit_odp_tunnel_action(flow, &ctx->base_flow,
+ ctx->xout->odp_actions);
+ flow->tunnel = flow_tnl; /* Restore tunnel metadata */
+ }
} else {
odp_port = xport->odp_port;
out_port = odp_port;
if (out_port != ODPP_NONE) {
ctx->xout->slow |= commit_odp_actions(flow, &ctx->base_flow,
- &ctx->xout->odp_actions,
- &ctx->xout->wc);
- nl_msg_put_odp_port(&ctx->xout->odp_actions, OVS_ACTION_ATTR_OUTPUT,
- out_port);
+ ctx->xout->odp_actions,
+ wc,
+ ctx->xbridge->masked_set_action);
+
+ if (ctx->use_recirc) {
+ struct ovs_action_hash *act_hash;
+ struct xlate_recirc *xr = &ctx->recirc;
+
+ /* Hash action. */
+ act_hash = nl_msg_put_unspec_uninit(ctx->xout->odp_actions,
+ OVS_ACTION_ATTR_HASH,
+ sizeof *act_hash);
+ act_hash->hash_alg = xr->hash_alg;
+ act_hash->hash_basis = xr->hash_basis;
+
+ /* Recirc action. */
+ nl_msg_put_u32(ctx->xout->odp_actions, OVS_ACTION_ATTR_RECIRC,
+ xr->recirc_id);
+ } else {
+
+ if (tnl_push_pop_send) {
+ build_tunnel_send(ctx, xport, flow, odp_port);
+ flow->tunnel = flow_tnl; /* Restore tunnel metadata */
+ } else {
+ odp_port_t odp_tnl_port = ODPP_NONE;
+
+ /* XXX: Write better Filter for tunnel port. We can use inport
+ * int tunnel-port flow to avoid these checks completely. */
+ if (ofp_port == OFPP_LOCAL &&
+ ovs_native_tunneling_is_on(ctx->xbridge->ofproto)) {
+
+ odp_tnl_port = tnl_port_map_lookup(flow, wc);
+ }
+
+ if (odp_tnl_port != ODPP_NONE) {
+ nl_msg_put_odp_port(ctx->xout->odp_actions,
+ OVS_ACTION_ATTR_TUNNEL_POP,
+ odp_tnl_port);
+ } else {
+ /* Tunnel push-pop action is not compatible with
+ * IPFIX action. */
+ add_ipfix_output_action(ctx, out_port);
+ nl_msg_put_odp_port(ctx->xout->odp_actions,
+ OVS_ACTION_ATTR_OUTPUT,
+ out_port);
+ }
+ }
+ }
ctx->sflow_odp_port = odp_port;
ctx->sflow_n_outputs++;
xlate_recursively(struct xlate_ctx *ctx, struct rule_dpif *rule)
{
struct rule_dpif *old_rule = ctx->rule;
- struct rule_actions *actions;
+ const struct rule_actions *actions;
if (ctx->xin->resubmit_stats) {
rule_dpif_credit_stats(rule, ctx->xin->resubmit_stats);
{
static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 1);
- if (ctx->recurse >= MAX_RESUBMIT_RECURSION) {
+ if (ctx->recurse >= MAX_RESUBMIT_RECURSION + MAX_INTERNAL_RESUBMITS) {
VLOG_ERR_RL(&rl, "resubmit actions recursed over %d times",
MAX_RESUBMIT_RECURSION);
- } else if (ctx->resubmits >= MAX_RESUBMITS) {
+ } else if (ctx->resubmits >= MAX_RESUBMITS + MAX_INTERNAL_RESUBMITS) {
VLOG_ERR_RL(&rl, "over %d resubmit actions", MAX_RESUBMITS);
- } else if (ctx->xout->odp_actions.size > UINT16_MAX) {
+ } else if (ofpbuf_size(ctx->xout->odp_actions) > UINT16_MAX) {
VLOG_ERR_RL(&rl, "resubmits yielded over 64 kB of actions");
- } else if (ctx->stack.size >= 65536) {
+ } else if (ofpbuf_size(&ctx->stack) >= 65536) {
VLOG_ERR_RL(&rl, "resubmits yielded over 64 kB of stack");
} else {
return true;
bool may_packet_in, bool honor_table_miss)
{
if (xlate_resubmit_resource_check(ctx)) {
- ofp_port_t old_in_port = ctx->xin->flow.in_port.ofp_port;
- bool skip_wildcards = ctx->xin->skip_wildcards;
+ struct flow_wildcards *wc;
uint8_t old_table_id = ctx->table_id;
struct rule_dpif *rule;
- enum rule_dpif_lookup_verdict verdict;
- enum ofputil_port_config config = 0;
ctx->table_id = table_id;
+ wc = (ctx->xin->skip_wildcards) ? NULL : &ctx->xout->wc;
- /* Look up a flow with 'in_port' as the input port. Then restore the
- * original input port (otherwise OFPP_NORMAL and OFPP_IN_PORT will
- * have surprising behavior). */
- ctx->xin->flow.in_port.ofp_port = in_port;
- verdict = rule_dpif_lookup_from_table(ctx->xbridge->ofproto,
- &ctx->xin->flow,
- !skip_wildcards
- ? &ctx->xout->wc : NULL,
- honor_table_miss,
- &ctx->table_id, &rule);
- ctx->xin->flow.in_port.ofp_port = old_in_port;
-
- if (ctx->xin->resubmit_hook) {
- ctx->xin->resubmit_hook(ctx->xin, rule, ctx->recurse);
- }
-
- switch (verdict) {
- case RULE_DPIF_LOOKUP_VERDICT_MATCH:
- goto match;
- case RULE_DPIF_LOOKUP_VERDICT_CONTROLLER:
- if (may_packet_in) {
- struct xport *xport;
-
- xport = get_ofp_port(ctx->xbridge,
- ctx->xin->flow.in_port.ofp_port);
- config = xport ? xport->config : 0;
- break;
- }
- /* Fall through to drop */
- case RULE_DPIF_LOOKUP_VERDICT_DROP:
- config = OFPUTIL_PC_NO_PACKET_IN;
- break;
- default:
- OVS_NOT_REACHED();
- }
+ rule = rule_dpif_lookup_from_table(ctx->xbridge->ofproto,
+ &ctx->xin->flow, wc,
+ ctx->xin->xcache != NULL,
+ ctx->xin->resubmit_stats,
+ &ctx->table_id, in_port,
+ may_packet_in, honor_table_miss);
- choose_miss_rule(config, ctx->xbridge->miss_rule,
- ctx->xbridge->no_packet_in_rule, &rule);
+ if (OVS_UNLIKELY(ctx->xin->resubmit_hook)) {
+ ctx->xin->resubmit_hook(ctx->xin, rule, ctx->recurse + 1);
+ }
-match:
if (rule) {
+ /* Fill in the cache entry here instead of xlate_recursively
+ * to make the reference counting more explicit. We take a
+ * reference in the lookups above if we are going to cache the
+ * rule. */
+ if (ctx->xin->xcache) {
+ struct xc_entry *entry;
+
+ entry = xlate_cache_add_entry(ctx->xin->xcache, XC_RULE);
+ entry->u.rule = rule;
+ }
xlate_recursively(ctx, rule);
- rule_dpif_unref(rule);
}
ctx->table_id = old_table_id;
}
static void
-xlate_group_bucket(struct xlate_ctx *ctx, const struct ofputil_bucket *bucket)
+xlate_group_stats(struct xlate_ctx *ctx, struct group_dpif *group,
+ struct ofputil_bucket *bucket)
+{
+ if (ctx->xin->resubmit_stats) {
+ group_dpif_credit_stats(group, bucket, ctx->xin->resubmit_stats);
+ }
+ if (ctx->xin->xcache) {
+ struct xc_entry *entry;
+
+ entry = xlate_cache_add_entry(ctx->xin->xcache, XC_GROUP);
+ entry->u.group.group = group_dpif_ref(group);
+ entry->u.group.bucket = bucket;
+ }
+}
+
+static void
+xlate_group_bucket(struct xlate_ctx *ctx, struct ofputil_bucket *bucket)
{
uint64_t action_list_stub[1024 / 8];
struct ofpbuf action_list, action_set;
ofpacts_execute_action_set(&action_list, &action_set);
ctx->recurse++;
- do_xlate_actions(action_list.data, action_list.size, ctx);
+ do_xlate_actions(ofpbuf_data(&action_list), ofpbuf_size(&action_list), ctx);
ctx->recurse--;
ofpbuf_uninit(&action_set);
static void
xlate_all_group(struct xlate_ctx *ctx, struct group_dpif *group)
{
- const struct ofputil_bucket *bucket;
+ struct ofputil_bucket *bucket;
const struct list *buckets;
struct flow old_flow = ctx->xin->flow;
* just before applying the all or indirect group. */
ctx->xin->flow = old_flow;
}
+ xlate_group_stats(ctx, group, NULL);
}
static void
xlate_ff_group(struct xlate_ctx *ctx, struct group_dpif *group)
{
- const struct ofputil_bucket *bucket;
+ struct ofputil_bucket *bucket;
bucket = group_first_live_bucket(ctx, group, 0);
if (bucket) {
xlate_group_bucket(ctx, bucket);
+ xlate_group_stats(ctx, group, bucket);
}
}
xlate_select_group(struct xlate_ctx *ctx, struct group_dpif *group)
{
struct flow_wildcards *wc = &ctx->xout->wc;
- const struct ofputil_bucket *bucket;
+ struct ofputil_bucket *bucket;
uint32_t basis;
- basis = hash_bytes(ctx->xin->flow.dl_dst, sizeof ctx->xin->flow.dl_dst, 0);
+ basis = flow_hash_symmetric_l4(&ctx->xin->flow, 0);
bucket = group_best_live_bucket(ctx, group, basis);
if (bucket) {
memset(&wc->masks.dl_dst, 0xff, sizeof wc->masks.dl_dst);
+ memset(&wc->masks.dl_src, 0xff, sizeof wc->masks.dl_src);
+ memset(&wc->masks.dl_type, 0xff, sizeof wc->masks.dl_type);
+ memset(&wc->masks.nw_dst, 0xff, sizeof wc->masks.nw_dst);
+ memset(&wc->masks.nw_proto, 0xff, sizeof wc->masks.nw_proto);
+ memset(&wc->masks.nw_src, 0xff, sizeof wc->masks.nw_src);
+ memset(&wc->masks.tp_dst, 0xff, sizeof wc->masks.tp_dst);
+ memset(&wc->masks.tp_src, 0xff, sizeof wc->masks.tp_src);
+ memset(&wc->masks.vlan_tci, 0xff, sizeof wc->masks.vlan_tci);
+
xlate_group_bucket(ctx, bucket);
+ xlate_group_stats(ctx, group, bucket);
}
}
default:
OVS_NOT_REACHED();
}
- group_dpif_release(group);
+ group_dpif_unref(group);
ctx->in_group = false;
}
{
ofp_port_t in_port;
uint8_t table_id;
+ bool may_packet_in = false;
+ bool honor_table_miss = false;
+
+ if (ctx->rule && rule_dpif_is_internal(ctx->rule)) {
+ /* Still allow missed packets to be sent to the controller
+ * if resubmitting from an internal table. */
+ may_packet_in = true;
+ honor_table_miss = true;
+ }
in_port = resubmit->in_port;
if (in_port == OFPP_IN_PORT) {
table_id = ctx->table_id;
}
- xlate_table_action(ctx, in_port, table_id, false, false);
+ xlate_table_action(ctx, in_port, table_id, may_packet_in,
+ honor_table_miss);
}
static void
uint16_t controller_id)
{
struct ofproto_packet_in *pin;
- struct ofpbuf *packet;
- struct pkt_metadata md = PKT_METADATA_INITIALIZER(0);
+ struct dpif_packet *packet;
ctx->xout->slow |= SLOW_CONTROLLER;
if (!ctx->xin->packet) {
return;
}
- packet = ofpbuf_clone(ctx->xin->packet);
+ packet = dpif_packet_clone_from_ofpbuf(ctx->xin->packet);
ctx->xout->slow |= commit_odp_actions(&ctx->xin->flow, &ctx->base_flow,
- &ctx->xout->odp_actions,
- &ctx->xout->wc);
+ ctx->xout->odp_actions,
+ &ctx->xout->wc,
+ ctx->xbridge->masked_set_action);
- odp_execute_actions(NULL, packet, false, &md, ctx->xout->odp_actions.data,
- ctx->xout->odp_actions.size, NULL);
+ odp_execute_actions(NULL, &packet, 1, false,
+ ofpbuf_data(ctx->xout->odp_actions),
+ ofpbuf_size(ctx->xout->odp_actions), NULL);
pin = xmalloc(sizeof *pin);
- pin->up.packet_len = packet->size;
- pin->up.packet = ofpbuf_steal_data(packet);
+ pin->up.packet_len = ofpbuf_size(&packet->ofpbuf);
+ pin->up.packet = ofpbuf_steal_data(&packet->ofpbuf);
pin->up.reason = reason;
pin->up.table_id = ctx->table_id;
pin->up.cookie = (ctx->rule
}
}
ofproto_dpif_send_packet_in(ctx->xbridge->ofproto, pin);
- ofpbuf_delete(packet);
+ dpif_packet_delete(packet);
+}
+
+static void
+compose_recirculate_action(struct xlate_ctx *ctx,
+ const struct ofpact *ofpacts_base,
+ const struct ofpact *ofpact_current,
+ size_t ofpacts_base_len)
+{
+ uint32_t id;
+ int error;
+ unsigned ofpacts_len;
+ struct match match;
+ struct rule *rule;
+ struct ofpbuf ofpacts;
+
+ ctx->exit = true;
+
+ ofpacts_len = ofpacts_base_len -
+ ((uint8_t *)ofpact_current - (uint8_t *)ofpacts_base);
+
+ if (ctx->rule) {
+ id = rule_dpif_get_recirc_id(ctx->rule);
+ } else {
+ /* In the case where ctx has no rule then allocate a recirc id.
+ * The life-cycle of this recirc id is managed by associating it
+ * with the internal rule that is created to to handle
+ * recirculation below.
+ *
+ * The known use-case of this is packet_out which
+ * translates actions without a rule */
+ id = ofproto_dpif_alloc_recirc_id(ctx->xbridge->ofproto);
+ }
+ if (!id) {
+ static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
+ VLOG_ERR_RL(&rl, "Failed to allocate recirculation id");
+ return;
+ }
+
+ match_init_catchall(&match);
+ match_set_recirc_id(&match, id);
+ ofpbuf_use_const(&ofpacts, ofpact_current, ofpacts_len);
+ error = ofproto_dpif_add_internal_flow(ctx->xbridge->ofproto, &match,
+ RECIRC_RULE_PRIORITY,
+ RECIRC_TIMEOUT, &ofpacts, &rule);
+ if (error) {
+ static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
+ VLOG_ERR_RL(&rl, "Failed to add post recirculation flow %s",
+ match_to_string(&match, 0));
+ return;
+ }
+ /* If ctx has no rule then associate the recirc id, which
+ * was allocated above, with the internal rule. This allows
+ * the recirc id to be released when the internal rule times out. */
+ if (!ctx->rule) {
+ rule_set_recirc_id(rule, id);
+ }
+
+ ctx->xout->slow |= commit_odp_actions(&ctx->xin->flow, &ctx->base_flow,
+ ctx->xout->odp_actions,
+ &ctx->xout->wc,
+ ctx->xbridge->masked_set_action);
+ nl_msg_put_u32(ctx->xout->odp_actions, OVS_ACTION_ATTR_RECIRC, id);
}
static void
n = flow_count_mpls_labels(flow, wc);
if (!n) {
ctx->xout->slow |= commit_odp_actions(flow, &ctx->base_flow,
- &ctx->xout->odp_actions,
- &ctx->xout->wc);
+ ctx->xout->odp_actions,
+ &ctx->xout->wc,
+ ctx->xbridge->masked_set_action);
} else if (n >= FLOW_MAX_MPLS_LABELS) {
if (ctx->xin->packet != NULL) {
static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
struct flow *flow = &ctx->xin->flow;
int n = flow_count_mpls_labels(flow, wc);
- if (!flow_pop_mpls(flow, n, eth_type, wc) && n >= FLOW_MAX_MPLS_LABELS) {
+ if (flow_pop_mpls(flow, n, eth_type, wc)) {
+ if (ctx->xbridge->enable_recirc && !eth_type_mpls(eth_type)) {
+ ctx->was_mpls = true;
+ }
+ } else if (n >= FLOW_MAX_MPLS_LABELS) {
if (ctx->xin->packet != NULL) {
static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
VLOG_WARN_RL(&rl, "bridge %s: dropping packet on which an "
ctx->xbridge->name, FLOW_MAX_MPLS_LABELS);
}
ctx->exit = true;
- ofpbuf_clear(&ctx->xout->odp_actions);
+ ofpbuf_clear(ctx->xout->odp_actions);
}
}
compose_dec_mpls_ttl_action(struct xlate_ctx *ctx)
{
struct flow *flow = &ctx->xin->flow;
- uint8_t ttl = mpls_lse_to_ttl(flow->mpls_lse[0]);
struct flow_wildcards *wc = &ctx->xout->wc;
- memset(&wc->masks.mpls_lse, 0xff, sizeof wc->masks.mpls_lse);
if (eth_type_mpls(flow->dl_type)) {
+ uint8_t ttl = mpls_lse_to_ttl(flow->mpls_lse[0]);
+
+ wc->masks.mpls_lse[0] |= htonl(MPLS_TTL_MASK);
if (ttl > 1) {
ttl--;
set_mpls_lse_ttl(&flow->mpls_lse[0], ttl);
return false;
} else {
execute_controller_action(ctx, UINT16_MAX, OFPR_INVALID_TTL, 0);
-
- /* Stop processing for current table. */
- return true;
}
- } else {
- return true;
}
+
+ /* Stop processing for current table. */
+ return true;
}
static void
flood_packets(ctx, true);
break;
case OFPP_CONTROLLER:
- execute_controller_action(ctx, max_len, OFPR_ACTION, 0);
+ execute_controller_action(ctx, max_len,
+ ctx->in_group ? OFPR_GROUP : OFPR_ACTION, 0);
break;
case OFPP_NONE:
break;
}
static void
-xlate_learn_action(struct xlate_ctx *ctx,
- const struct ofpact_learn *learn)
+xlate_learn_action__(struct xlate_ctx *ctx, const struct ofpact_learn *learn,
+ struct ofputil_flow_mod *fm, struct ofpbuf *ofpacts)
{
- uint64_t ofpacts_stub[1024 / 8];
- struct ofputil_flow_mod fm;
- struct ofpbuf ofpacts;
+ learn_execute(learn, &ctx->xin->flow, fm, ofpacts);
+ if (ctx->xin->may_learn) {
+ ofproto_dpif_flow_mod(ctx->xbridge->ofproto, fm);
+ }
+}
+static void
+xlate_learn_action(struct xlate_ctx *ctx, const struct ofpact_learn *learn)
+{
ctx->xout->has_learn = true;
-
learn_mask(learn, &ctx->xout->wc);
- if (!ctx->xin->may_learn) {
- return;
+ if (ctx->xin->xcache) {
+ struct xc_entry *entry;
+
+ entry = xlate_cache_add_entry(ctx->xin->xcache, XC_LEARN);
+ entry->u.learn.ofproto = ctx->xbridge->ofproto;
+ entry->u.learn.fm = xmalloc(sizeof *entry->u.learn.fm);
+ entry->u.learn.ofpacts = ofpbuf_new(64);
+ xlate_learn_action__(ctx, learn, entry->u.learn.fm,
+ entry->u.learn.ofpacts);
+ } else if (ctx->xin->may_learn) {
+ uint64_t ofpacts_stub[1024 / 8];
+ struct ofputil_flow_mod fm;
+ struct ofpbuf ofpacts;
+
+ ofpbuf_use_stub(&ofpacts, ofpacts_stub, sizeof ofpacts_stub);
+ xlate_learn_action__(ctx, learn, &fm, &ofpacts);
+ ofpbuf_uninit(&ofpacts);
}
+}
- ofpbuf_use_stub(&ofpacts, ofpacts_stub, sizeof ofpacts_stub);
- learn_execute(learn, &ctx->xin->flow, &fm, &ofpacts);
- ofproto_dpif_flow_mod(ctx->xbridge->ofproto, &fm);
- ofpbuf_uninit(&ofpacts);
+static void
+xlate_fin_timeout__(struct rule_dpif *rule, uint16_t tcp_flags,
+ uint16_t idle_timeout, uint16_t hard_timeout)
+{
+ if (tcp_flags & (TCP_FIN | TCP_RST)) {
+ rule_dpif_reduce_timeouts(rule, idle_timeout, hard_timeout);
+ }
}
static void
xlate_fin_timeout(struct xlate_ctx *ctx,
const struct ofpact_fin_timeout *oft)
{
- if (ctx->xin->tcp_flags & (TCP_FIN | TCP_RST) && ctx->rule) {
- rule_dpif_reduce_timeouts(ctx->rule, oft->fin_idle_timeout,
- oft->fin_hard_timeout);
+ if (ctx->rule) {
+ xlate_fin_timeout__(ctx->rule, ctx->xin->tcp_flags,
+ oft->fin_idle_timeout, oft->fin_hard_timeout);
+ if (ctx->xin->xcache) {
+ struct xc_entry *entry;
+
+ entry = xlate_cache_add_entry(ctx->xin->xcache, XC_FIN_TIMEOUT);
+ /* XC_RULE already holds a reference on the rule, none is taken
+ * here. */
+ entry->u.fin.rule = ctx->rule;
+ entry->u.fin.idle = oft->fin_idle_timeout;
+ entry->u.fin.hard = oft->fin_hard_timeout;
+ }
}
}
}
ctx->xout->slow |= commit_odp_actions(&ctx->xin->flow, &ctx->base_flow,
- &ctx->xout->odp_actions,
- &ctx->xout->wc);
+ ctx->xout->odp_actions,
+ &ctx->xout->wc,
+ ctx->xbridge->masked_set_action);
compose_flow_sample_cookie(os->probability, os->collector_set_id,
os->obs_domain_id, os->obs_point_id, &cookie);
- compose_sample_action(ctx->xbridge, &ctx->xout->odp_actions, &ctx->xin->flow,
- probability, &cookie, sizeof cookie.flow_sample);
+ compose_sample_action(ctx->xbridge, ctx->xout->odp_actions, &ctx->xin->flow,
+ probability, &cookie, sizeof cookie.flow_sample,
+ ODPP_NONE);
}
static bool
may_receive(const struct xport *xport, struct xlate_ctx *ctx)
{
- if (xport->config & (eth_addr_equals(ctx->xin->flow.dl_dst, eth_addr_stp)
+ if (xport->config & (is_stp(&ctx->xin->flow)
? OFPUTIL_PC_NO_RECV_STP
: OFPUTIL_PC_NO_RECV)) {
return false;
* disabled. If just learning is enabled, we need to have
* OFPP_NORMAL and the learning action have a look at the packet
* before we can drop it. */
- if (!xport_stp_forward_state(xport) && !xport_stp_learn_state(xport)) {
+ if ((!xport_stp_forward_state(xport) && !xport_stp_learn_state(xport)) ||
+ (!xport_rstp_forward_state(xport) && !xport_rstp_learn_state(xport))) {
return false;
}
static void
xlate_write_actions(struct xlate_ctx *ctx, const struct ofpact *a)
{
- struct ofpact_nest *on = ofpact_get_WRITE_ACTIONS(a);
- ofpbuf_put(&ctx->action_set, on->actions, ofpact_nest_get_action_len(on));
+ const struct ofpact_nest *on = ofpact_get_WRITE_ACTIONS(a);
+ size_t on_len = ofpact_nest_get_action_len(on);
+ const struct ofpact *inner;
+
+ /* Maintain actset_output depending on the contents of the action set:
+ *
+ * - OFPP_UNSET, if there is no "output" action.
+ *
+ * - The output port, if there is an "output" action and no "group"
+ * action.
+ *
+ * - OFPP_UNSET, if there is a "group" action.
+ */
+ if (!ctx->action_set_has_group) {
+ OFPACT_FOR_EACH (inner, on->actions, on_len) {
+ if (inner->type == OFPACT_OUTPUT) {
+ ctx->xin->flow.actset_output = ofpact_get_OUTPUT(inner)->port;
+ } else if (inner->type == OFPACT_GROUP) {
+ ctx->xin->flow.actset_output = OFPP_UNSET;
+ ctx->action_set_has_group = true;
+ }
+ }
+ }
+
+ ofpbuf_put(&ctx->action_set, on->actions, on_len);
ofpact_pad(&ctx->action_set);
}
ofpbuf_use_stub(&action_list, action_list_stub, sizeof action_list_stub);
ofpacts_execute_action_set(&action_list, &ctx->action_set);
- do_xlate_actions(action_list.data, action_list.size, ctx);
+ do_xlate_actions(ofpbuf_data(&action_list), ofpbuf_size(&action_list), ctx);
ofpbuf_uninit(&action_list);
}
+static bool
+ofpact_needs_recirculation_after_mpls(const struct xlate_ctx *ctx,
+ const struct ofpact *a)
+{
+ struct flow_wildcards *wc = &ctx->xout->wc;
+ struct flow *flow = &ctx->xin->flow;
+
+ switch (a->type) {
+ case OFPACT_OUTPUT:
+ case OFPACT_GROUP:
+ case OFPACT_CONTROLLER:
+ case OFPACT_STRIP_VLAN:
+ case OFPACT_SET_VLAN_PCP:
+ case OFPACT_SET_VLAN_VID:
+ case OFPACT_ENQUEUE:
+ case OFPACT_PUSH_VLAN:
+ case OFPACT_SET_ETH_SRC:
+ case OFPACT_SET_ETH_DST:
+ case OFPACT_SET_TUNNEL:
+ case OFPACT_SET_QUEUE:
+ case OFPACT_POP_QUEUE:
+ case OFPACT_POP_MPLS:
+ case OFPACT_DEC_MPLS_TTL:
+ case OFPACT_SET_MPLS_TTL:
+ case OFPACT_SET_MPLS_TC:
+ case OFPACT_SET_MPLS_LABEL:
+ case OFPACT_NOTE:
+ case OFPACT_OUTPUT_REG:
+ case OFPACT_EXIT:
+ case OFPACT_METER:
+ case OFPACT_WRITE_METADATA:
+ case OFPACT_WRITE_ACTIONS:
+ case OFPACT_CLEAR_ACTIONS:
+ case OFPACT_SAMPLE:
+ return false;
+
+ case OFPACT_SET_IPV4_SRC:
+ case OFPACT_SET_IPV4_DST:
+ case OFPACT_SET_IP_DSCP:
+ case OFPACT_SET_IP_ECN:
+ case OFPACT_SET_IP_TTL:
+ case OFPACT_SET_L4_SRC_PORT:
+ case OFPACT_SET_L4_DST_PORT:
+ case OFPACT_RESUBMIT:
+ case OFPACT_STACK_PUSH:
+ case OFPACT_STACK_POP:
+ case OFPACT_DEC_TTL:
+ case OFPACT_MULTIPATH:
+ case OFPACT_BUNDLE:
+ case OFPACT_LEARN:
+ case OFPACT_FIN_TIMEOUT:
+ case OFPACT_GOTO_TABLE:
+ return true;
+
+ case OFPACT_REG_MOVE:
+ return (mf_is_l3_or_higher(ofpact_get_REG_MOVE(a)->dst.field) ||
+ mf_is_l3_or_higher(ofpact_get_REG_MOVE(a)->src.field));
+
+ case OFPACT_SET_FIELD:
+ return mf_is_l3_or_higher(ofpact_get_SET_FIELD(a)->field);
+
+ case OFPACT_PUSH_MPLS:
+ /* Recirculate if it is an IP packet with a zero ttl. This may
+ * indicate that the packet was previously MPLS and an MPLS pop action
+ * converted it to IP. In this case recirculating should reveal the IP
+ * TTL which is used as the basis for a new MPLS LSE. */
+ return (!flow_count_mpls_labels(flow, wc)
+ && flow->nw_ttl == 0
+ && is_ip_any(flow));
+ }
+
+ OVS_NOT_REACHED();
+}
+
static void
do_xlate_actions(const struct ofpact *ofpacts, size_t ofpacts_len,
struct xlate_ctx *ctx)
struct flow *flow = &ctx->xin->flow;
const struct ofpact *a;
+ if (ovs_native_tunneling_is_on(ctx->xbridge->ofproto)) {
+ tnl_arp_snoop(flow, wc, ctx->xbridge->name);
+ }
/* dl_type already in the mask, not set below. */
OFPACT_FOR_EACH (a, ofpacts, ofpacts_len) {
break;
}
+ if (ctx->was_mpls && ofpact_needs_recirculation_after_mpls(ctx, a)) {
+ compose_recirculate_action(ctx, ofpacts, a, ofpacts_len);
+ return;
+ }
+
switch (a->type) {
case OFPACT_OUTPUT:
xlate_output_action(ctx, ofpact_get_OUTPUT(a)->port,
break;
case OFPACT_ENQUEUE:
+ memset(&wc->masks.skb_priority, 0xff,
+ sizeof wc->masks.skb_priority);
xlate_enqueue_action(ctx, ofpact_get_ENQUEUE(a));
break;
break;
case OFPACT_SET_L4_SRC_PORT:
- if (is_ip_any(flow)) {
+ if (is_ip_any(flow) && !(flow->nw_frag & FLOW_NW_FRAG_LATER)) {
memset(&wc->masks.nw_proto, 0xff, sizeof wc->masks.nw_proto);
memset(&wc->masks.tp_src, 0xff, sizeof wc->masks.tp_src);
flow->tp_src = htons(ofpact_get_SET_L4_SRC_PORT(a)->port);
break;
case OFPACT_SET_L4_DST_PORT:
- if (is_ip_any(flow)) {
+ if (is_ip_any(flow) && !(flow->nw_frag & FLOW_NW_FRAG_LATER)) {
memset(&wc->masks.nw_proto, 0xff, sizeof wc->masks.nw_proto);
memset(&wc->masks.tp_dst, 0xff, sizeof wc->masks.tp_dst);
flow->tp_dst = htons(ofpact_get_SET_L4_DST_PORT(a)->port);
break;
case OFPACT_SET_QUEUE:
+ memset(&wc->masks.skb_priority, 0xff,
+ sizeof wc->masks.skb_priority);
xlate_set_queue_action(ctx, ofpact_get_SET_QUEUE(a)->queue_id);
break;
case OFPACT_POP_QUEUE:
+ memset(&wc->masks.skb_priority, 0xff,
+ sizeof wc->masks.skb_priority);
flow->skb_priority = ctx->orig_skb_priority;
break;
nxm_execute_reg_move(ofpact_get_REG_MOVE(a), flow, wc);
break;
- case OFPACT_REG_LOAD:
- nxm_execute_reg_load(ofpact_get_REG_LOAD(a), flow, wc);
- break;
-
case OFPACT_SET_FIELD:
set_field = ofpact_get_SET_FIELD(a);
mf = set_field->field;
- mf_mask_field_and_prereqs(mf, &wc->masks);
/* Set field action only ever overwrites packet's outermost
* applicable header fields. Do nothing if no header exists. */
- if ((mf->id != MFF_VLAN_VID || flow->vlan_tci & htons(VLAN_CFI))
- && ((mf->id != MFF_MPLS_LABEL && mf->id != MFF_MPLS_TC)
- || eth_type_mpls(flow->dl_type))) {
- mf_set_flow_value(mf, &set_field->value, flow);
+ if (mf->id == MFF_VLAN_VID) {
+ wc->masks.vlan_tci |= htons(VLAN_CFI);
+ if (!(flow->vlan_tci & htons(VLAN_CFI))) {
+ break;
+ }
+ } else if ((mf->id == MFF_MPLS_LABEL || mf->id == MFF_MPLS_TC)
+ /* 'dl_type' is already unwildcarded. */
+ && !eth_type_mpls(flow->dl_type)) {
+ break;
+ }
+ /* A flow may wildcard nw_frag. Do nothing if setting a trasport
+ * header field on a packet that does not have them. */
+ mf_mask_field_and_prereqs(mf, &wc->masks);
+ if (mf_are_prereqs_ok(mf, flow)) {
+ mf_set_flow_value_masked(mf, &set_field->value,
+ &set_field->mask, flow);
}
break;
case OFPACT_CLEAR_ACTIONS:
ofpbuf_clear(&ctx->action_set);
+ ctx->xin->flow.actset_output = OFPP_UNSET;
+ ctx->action_set_has_group = false;
break;
case OFPACT_WRITE_ACTIONS:
case OFPACT_GOTO_TABLE: {
struct ofpact_goto_table *ogt = ofpact_get_GOTO_TABLE(a);
- ovs_assert(ctx->table_id < ogt->table_id);
+ /* Allow ctx->table_id == TBL_INTERNAL, which will be greater
+ * than ogt->table_id. This is to allow goto_table actions that
+ * triggered recirculation: ctx->table_id will be TBL_INTERNAL
+ * after recirculation. */
+ ovs_assert(ctx->table_id == TBL_INTERNAL
+ || ctx->table_id < ogt->table_id);
xlate_table_action(ctx, ctx->xin->flow.in_port.ofp_port,
ogt->table_id, true, true);
break;
void
xlate_in_init(struct xlate_in *xin, struct ofproto_dpif *ofproto,
- const struct flow *flow, struct rule_dpif *rule,
- uint16_t tcp_flags, const struct ofpbuf *packet)
+ const struct flow *flow, ofp_port_t in_port,
+ struct rule_dpif *rule, uint16_t tcp_flags,
+ const struct ofpbuf *packet)
{
xin->ofproto = ofproto;
xin->flow = *flow;
+ xin->flow.in_port.ofp_port = in_port;
+ xin->flow.actset_output = OFPP_UNSET;
xin->packet = packet;
xin->may_learn = packet != NULL;
xin->rule = rule;
+ xin->xcache = NULL;
xin->ofpacts = NULL;
xin->ofpacts_len = 0;
xin->tcp_flags = tcp_flags;
xin->report_hook = NULL;
xin->resubmit_stats = NULL;
xin->skip_wildcards = false;
+ xin->odp_actions = NULL;
}
void
xlate_out_uninit(struct xlate_out *xout)
{
- if (xout) {
- ofpbuf_uninit(&xout->odp_actions);
+ if (xout && xout->odp_actions == &xout->odp_actions_buf) {
+ ofpbuf_uninit(xout->odp_actions);
}
}
xlate_out_uninit(&xout);
}
-static void
-xlate_report(struct xlate_ctx *ctx, const char *s)
-{
- if (ctx->xin->report_hook) {
- ctx->xin->report_hook(ctx->xin, s, ctx->recurse);
- }
-}
-
void
xlate_out_copy(struct xlate_out *dst, const struct xlate_out *src)
{
dst->nf_output_iface = src->nf_output_iface;
dst->mirrors = src->mirrors;
- ofpbuf_use_stub(&dst->odp_actions, dst->odp_actions_stub,
+ dst->odp_actions = &dst->odp_actions_buf;
+ ofpbuf_use_stub(dst->odp_actions, dst->odp_actions_stub,
sizeof dst->odp_actions_stub);
- ofpbuf_put(&dst->odp_actions, src->odp_actions.data,
- src->odp_actions.size);
+ ofpbuf_put(dst->odp_actions, ofpbuf_data(src->odp_actions),
+ ofpbuf_size(src->odp_actions));
}
\f
static struct skb_priority_to_dscp *
return pdscp != NULL;
}
+static size_t
+count_skb_priorities(const struct xport *xport)
+{
+ return hmap_count(&xport->skb_priorities);
+}
+
static void
clear_skb_priorities(struct xport *xport)
{
const struct nlattr *a;
unsigned int left;
- NL_ATTR_FOR_EACH_UNSAFE (a, left, ctx->xout->odp_actions.data,
- ctx->xout->odp_actions.size) {
+ NL_ATTR_FOR_EACH_UNSAFE (a, left, ofpbuf_data(ctx->xout->odp_actions),
+ ofpbuf_size(ctx->xout->odp_actions)) {
if (nl_attr_type(a) == OVS_ACTION_ATTR_OUTPUT
&& nl_attr_get_odp_port(a) == local_odp_port) {
return true;
return false;
}
-/* Thread safe call to xlate_actions__(). */
-void
-xlate_actions(struct xlate_in *xin, struct xlate_out *xout)
- OVS_EXCLUDED(xlate_rwlock)
+#if defined(__linux__)
+/* Returns the maximum number of packets that the Linux kernel is willing to
+ * queue up internally to certain kinds of software-implemented ports, or the
+ * default (and rarely modified) value if it cannot be determined. */
+static int
+netdev_max_backlog(void)
+{
+ static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER;
+ static int max_backlog = 1000; /* The normal default value. */
+
+ if (ovsthread_once_start(&once)) {
+ static const char filename[] = "/proc/sys/net/core/netdev_max_backlog";
+ FILE *stream;
+ int n;
+
+ stream = fopen(filename, "r");
+ if (!stream) {
+ VLOG_WARN("%s: open failed (%s)", filename, ovs_strerror(errno));
+ } else {
+ if (fscanf(stream, "%d", &n) != 1) {
+ VLOG_WARN("%s: read error", filename);
+ } else if (n <= 100) {
+ VLOG_WARN("%s: unexpectedly small value %d", filename, n);
+ } else {
+ max_backlog = n;
+ }
+ fclose(stream);
+ }
+ ovsthread_once_done(&once);
+
+ VLOG_DBG("%s: using %d max_backlog", filename, max_backlog);
+ }
+
+ return max_backlog;
+}
+
+/* Counts and returns the number of OVS_ACTION_ATTR_OUTPUT actions in
+ * 'odp_actions'. */
+static int
+count_output_actions(const struct ofpbuf *odp_actions)
+{
+ const struct nlattr *a;
+ size_t left;
+ int n = 0;
+
+ NL_ATTR_FOR_EACH_UNSAFE (a, left, ofpbuf_data(odp_actions),
+ ofpbuf_size(odp_actions)) {
+ if (a->nla_type == OVS_ACTION_ATTR_OUTPUT) {
+ n++;
+ }
+ }
+ return n;
+}
+#endif /* defined(__linux__) */
+
+/* Returns true if 'odp_actions' contains more output actions than the datapath
+ * can reliably handle in one go. On Linux, this is the value of the
+ * net.core.netdev_max_backlog sysctl, which limits the maximum number of
+ * packets that the kernel is willing to queue up for processing while the
+ * datapath is processing a set of actions. */
+static bool
+too_many_output_actions(const struct ofpbuf *odp_actions OVS_UNUSED)
{
- ovs_rwlock_rdlock(&xlate_rwlock);
- xlate_actions__(xin, xout);
- ovs_rwlock_unlock(&xlate_rwlock);
+#ifdef __linux__
+ return (ofpbuf_size(odp_actions) / NL_A_U32_SIZE > netdev_max_backlog()
+ && count_output_actions(odp_actions) > netdev_max_backlog());
+#else
+ /* OSes other than Linux might have similar limits, but we don't know how
+ * to determine them.*/
+ return false;
+#endif
}
/* Translates the 'ofpacts_len' bytes of "struct ofpacts" starting at 'ofpacts'
*
* The caller must take responsibility for eventually freeing 'xout', with
* xlate_out_uninit(). */
-static void
-xlate_actions__(struct xlate_in *xin, struct xlate_out *xout)
- OVS_REQ_RDLOCK(xlate_rwlock)
+void
+xlate_actions(struct xlate_in *xin, struct xlate_out *xout)
{
+ struct xlate_cfg *xcfg = ovsrcu_get(struct xlate_cfg *, &xcfgp);
struct flow_wildcards *wc = &xout->wc;
struct flow *flow = &xin->flow;
struct rule_dpif *rule = NULL;
- struct rule_actions *actions = NULL;
enum slow_path_reason special;
const struct ofpact *ofpacts;
struct xport *in_port;
ctx.xout->has_fin_timeout = false;
ctx.xout->nf_output_iface = NF_OUT_DROP;
ctx.xout->mirrors = 0;
- ofpbuf_use_stub(&ctx.xout->odp_actions, ctx.xout->odp_actions_stub,
- sizeof ctx.xout->odp_actions_stub);
- ofpbuf_reserve(&ctx.xout->odp_actions, NL_A_U32_SIZE);
- ctx.xbridge = xbridge_lookup(xin->ofproto);
+ xout->odp_actions = xin->odp_actions;
+ if (!xout->odp_actions) {
+ xout->odp_actions = &xout->odp_actions_buf;
+ ofpbuf_use_stub(xout->odp_actions, xout->odp_actions_stub,
+ sizeof xout->odp_actions_stub);
+ }
+ ofpbuf_reserve(xout->odp_actions, NL_A_U32_SIZE);
+
+ ctx.xbridge = xbridge_lookup(xcfg, xin->ofproto);
if (!ctx.xbridge) {
- goto out;
+ return;
}
ctx.rule = xin->rule;
flow_wildcards_init_catchall(wc);
memset(&wc->masks.in_port, 0xff, sizeof wc->masks.in_port);
- memset(&wc->masks.skb_priority, 0xff, sizeof wc->masks.skb_priority);
memset(&wc->masks.dl_type, 0xff, sizeof wc->masks.dl_type);
if (is_ip_any(flow)) {
wc->masks.nw_frag |= FLOW_NW_FRAG_MASK;
ctx.orig_skb_priority = flow->skb_priority;
ctx.table_id = 0;
ctx.exit = false;
+ ctx.use_recirc = false;
+ ctx.was_mpls = false;
if (!xin->ofpacts && !ctx.rule) {
- ctx.table_id = rule_dpif_lookup(ctx.xbridge->ofproto, flow,
- !xin->skip_wildcards ? wc : NULL,
- &rule);
+ rule = rule_dpif_lookup(ctx.xbridge->ofproto, flow,
+ xin->skip_wildcards ? NULL : wc,
+ ctx.xin->xcache != NULL,
+ ctx.xin->resubmit_stats, &ctx.table_id);
if (ctx.xin->resubmit_stats) {
rule_dpif_credit_stats(rule, ctx.xin->resubmit_stats);
}
+ if (ctx.xin->xcache) {
+ struct xc_entry *entry;
+
+ entry = xlate_cache_add_entry(ctx.xin->xcache, XC_RULE);
+ entry->u.rule = rule;
+ }
ctx.rule = rule;
+
+ if (OVS_UNLIKELY(ctx.xin->resubmit_hook)) {
+ ctx.xin->resubmit_hook(ctx.xin, rule, 0);
+ }
}
xout->fail_open = ctx.rule && rule_dpif_is_fail_open(ctx.rule);
ofpacts = xin->ofpacts;
ofpacts_len = xin->ofpacts_len;
} else if (ctx.rule) {
- actions = rule_dpif_get_actions(ctx.rule);
+ const struct rule_actions *actions = rule_dpif_get_actions(ctx.rule);
+
ofpacts = actions->ofpacts;
ofpacts_len = actions->ofpacts_len;
} else {
}
ofpbuf_use_stub(&ctx.stack, ctx.init_stack, sizeof ctx.init_stack);
+
+ ctx.action_set_has_group = false;
ofpbuf_use_stub(&ctx.action_set,
ctx.action_set_stub, sizeof ctx.action_set_stub);
orig_flow = *flow;
}
- if (flow->nw_frag & FLOW_NW_FRAG_ANY) {
- switch (ctx.xbridge->frag) {
- case OFPC_FRAG_NORMAL:
- /* We must pretend that transport ports are unavailable. */
- flow->tp_src = ctx.base_flow.tp_src = htons(0);
- flow->tp_dst = ctx.base_flow.tp_dst = htons(0);
- break;
-
- case OFPC_FRAG_DROP:
- goto out;
-
- case OFPC_FRAG_REASM:
- OVS_NOT_REACHED();
-
- case OFPC_FRAG_NX_MATCH:
- /* Nothing to do. */
- break;
-
- case OFPC_INVALID_TTL_TO_CONTROLLER:
- OVS_NOT_REACHED();
+ in_port = get_ofp_port(ctx.xbridge, flow->in_port.ofp_port);
+ if (in_port && in_port->is_tunnel) {
+ if (ctx.xin->resubmit_stats) {
+ netdev_vport_inc_rx(in_port->netdev, ctx.xin->resubmit_stats);
+ if (in_port->bfd) {
+ bfd_account_rx(in_port->bfd, ctx.xin->resubmit_stats);
+ }
}
- }
+ if (ctx.xin->xcache) {
+ struct xc_entry *entry;
- in_port = get_ofp_port(ctx.xbridge, flow->in_port.ofp_port);
- if (in_port && in_port->is_tunnel && ctx.xin->resubmit_stats) {
- netdev_vport_inc_rx(in_port->netdev, ctx.xin->resubmit_stats);
- if (in_port->bfd) {
- bfd_account_rx(in_port->bfd, ctx.xin->resubmit_stats);
+ entry = xlate_cache_add_entry(ctx.xin->xcache, XC_NETDEV);
+ entry->u.dev.rx = netdev_ref(in_port->netdev);
+ entry->u.dev.bfd = bfd_ref(in_port->bfd);
}
}
add_sflow_action(&ctx);
add_ipfix_action(&ctx);
- sample_actions_len = ctx.xout->odp_actions.size;
+ sample_actions_len = ofpbuf_size(ctx.xout->odp_actions);
if (tnl_may_send && (!in_port || may_receive(in_port, &ctx))) {
do_xlate_actions(ofpacts, ofpacts_len, &ctx);
/* We've let OFPP_NORMAL and the learning action look at the
* packet, so drop it now if forwarding is disabled. */
- if (in_port && !xport_stp_forward_state(in_port)) {
- ctx.xout->odp_actions.size = sample_actions_len;
+ if (in_port && (!xport_stp_forward_state(in_port) ||
+ !xport_rstp_forward_state(in_port))) {
+ ofpbuf_set_size(ctx.xout->odp_actions, sample_actions_len);
}
}
- if (ctx.action_set.size) {
+ if (ofpbuf_size(&ctx.action_set)) {
xlate_action_set(&ctx);
}
}
}
- if (nl_attr_oversized(ctx.xout->odp_actions.size)) {
+ if (nl_attr_oversized(ofpbuf_size(ctx.xout->odp_actions))) {
/* These datapath actions are too big for a Netlink attribute, so we
* can't hand them to the kernel directly. dpif_execute() can execute
* them one by one with help, so just mark the result as SLOW_ACTION to
* prevent the flow from being installed. */
COVERAGE_INC(xlate_actions_oversize);
ctx.xout->slow |= SLOW_ACTION;
+ } else if (too_many_output_actions(ctx.xout->odp_actions)) {
+ COVERAGE_INC(xlate_actions_too_many_output);
+ ctx.xout->slow |= SLOW_ACTION;
+ }
+
+ if (mbridge_has_mirrors(ctx.xbridge->mbridge)) {
+ if (ctx.xin->resubmit_stats) {
+ mirror_update_stats(ctx.xbridge->mbridge, xout->mirrors,
+ ctx.xin->resubmit_stats->n_packets,
+ ctx.xin->resubmit_stats->n_bytes);
+ }
+ if (ctx.xin->xcache) {
+ struct xc_entry *entry;
+
+ entry = xlate_cache_add_entry(ctx.xin->xcache, XC_MIRROR);
+ entry->u.mirror.mbridge = mbridge_ref(ctx.xbridge->mbridge);
+ entry->u.mirror.mirrors = xout->mirrors;
+ }
}
- if (ctx.xin->resubmit_stats) {
- mirror_update_stats(ctx.xbridge->mbridge, xout->mirrors,
- ctx.xin->resubmit_stats->n_packets,
- ctx.xin->resubmit_stats->n_bytes);
-
- if (ctx.xbridge->netflow) {
- const struct ofpact *ofpacts;
- size_t ofpacts_len;
-
- ofpacts_len = actions->ofpacts_len;
- ofpacts = actions->ofpacts;
- if (ofpacts_len == 0
- || ofpacts->type != OFPACT_CONTROLLER
- || ofpact_next(ofpacts) < ofpact_end(ofpacts, ofpacts_len)) {
- /* Only update netflow if we don't have controller flow. We don't
- * report NetFlow expiration messages for such facets because they
- * are just part of the control logic for the network, not real
- * traffic. */
+ if (ctx.xbridge->netflow) {
+ /* Only update netflow if we don't have controller flow. We don't
+ * report NetFlow expiration messages for such facets because they
+ * are just part of the control logic for the network, not real
+ * traffic. */
+ if (ofpacts_len == 0
+ || ofpacts->type != OFPACT_CONTROLLER
+ || ofpact_next(ofpacts) < ofpact_end(ofpacts, ofpacts_len)) {
+ if (ctx.xin->resubmit_stats) {
netflow_flow_update(ctx.xbridge->netflow, flow,
xout->nf_output_iface,
ctx.xin->resubmit_stats);
}
+ if (ctx.xin->xcache) {
+ struct xc_entry *entry;
+
+ entry = xlate_cache_add_entry(ctx.xin->xcache, XC_NETFLOW);
+ entry->u.nf.netflow = netflow_ref(ctx.xbridge->netflow);
+ entry->u.nf.flow = xmemdup(flow, sizeof *flow);
+ entry->u.nf.iface = xout->nf_output_iface;
+ }
}
}
wc->masks.tp_src &= htons(UINT8_MAX);
wc->masks.tp_dst &= htons(UINT8_MAX);
}
-
-out:
- rule_dpif_unref(rule);
}
/* Sends 'packet' out 'ofport'.
int
xlate_send_packet(const struct ofport_dpif *ofport, struct ofpbuf *packet)
{
+ struct xlate_cfg *xcfg = ovsrcu_get(struct xlate_cfg *, &xcfgp);
struct xport *xport;
struct ofpact_output output;
struct flow flow;
flow_extract(packet, NULL, &flow);
flow.in_port.ofp_port = OFPP_NONE;
- ovs_rwlock_rdlock(&xlate_rwlock);
- xport = xport_lookup(ofport);
+ xport = xport_lookup(xcfg, ofport);
if (!xport) {
- ovs_rwlock_unlock(&xlate_rwlock);
return EINVAL;
}
output.port = xport->ofp_port;
output.max_len = 0;
- ovs_rwlock_unlock(&xlate_rwlock);
return ofproto_dpif_execute_actions(xport->xbridge->ofproto, &flow, NULL,
&output.ofpact, sizeof output,
packet);
}
+
+struct xlate_cache *
+xlate_cache_new(void)
+{
+ struct xlate_cache *xcache = xmalloc(sizeof *xcache);
+
+ ofpbuf_init(&xcache->entries, 512);
+ return xcache;
+}
+
+static struct xc_entry *
+xlate_cache_add_entry(struct xlate_cache *xcache, enum xc_type type)
+{
+ struct xc_entry *entry;
+
+ entry = ofpbuf_put_zeros(&xcache->entries, sizeof *entry);
+ entry->type = type;
+
+ return entry;
+}
+
+static void
+xlate_cache_netdev(struct xc_entry *entry, const struct dpif_flow_stats *stats)
+{
+ if (entry->u.dev.tx) {
+ netdev_vport_inc_tx(entry->u.dev.tx, stats);
+ }
+ if (entry->u.dev.rx) {
+ netdev_vport_inc_rx(entry->u.dev.rx, stats);
+ }
+ if (entry->u.dev.bfd) {
+ bfd_account_rx(entry->u.dev.bfd, stats);
+ }
+}
+
+static void
+xlate_cache_normal(struct ofproto_dpif *ofproto, struct flow *flow, int vlan)
+{
+ struct xlate_cfg *xcfg = ovsrcu_get(struct xlate_cfg *, &xcfgp);
+ struct xbridge *xbridge;
+ struct xbundle *xbundle;
+ struct flow_wildcards wc;
+
+ xbridge = xbridge_lookup(xcfg, ofproto);
+ if (!xbridge) {
+ return;
+ }
+
+ xbundle = lookup_input_bundle(xbridge, flow->in_port.ofp_port, false,
+ NULL);
+ if (!xbundle) {
+ return;
+ }
+
+ update_learning_table(xbridge, flow, &wc, vlan, xbundle);
+}
+
+/* Push stats and perform side effects of flow translation. */
+void
+xlate_push_stats(struct xlate_cache *xcache,
+ const struct dpif_flow_stats *stats)
+{
+ struct xc_entry *entry;
+ struct ofpbuf entries = xcache->entries;
+ uint8_t dmac[ETH_ADDR_LEN];
+
+ if (!stats->n_packets) {
+ return;
+ }
+
+ XC_ENTRY_FOR_EACH (entry, entries, xcache) {
+ switch (entry->type) {
+ case XC_RULE:
+ rule_dpif_credit_stats(entry->u.rule, stats);
+ break;
+ case XC_BOND:
+ bond_account(entry->u.bond.bond, entry->u.bond.flow,
+ entry->u.bond.vid, stats->n_bytes);
+ break;
+ case XC_NETDEV:
+ xlate_cache_netdev(entry, stats);
+ break;
+ case XC_NETFLOW:
+ netflow_flow_update(entry->u.nf.netflow, entry->u.nf.flow,
+ entry->u.nf.iface, stats);
+ break;
+ case XC_MIRROR:
+ mirror_update_stats(entry->u.mirror.mbridge,
+ entry->u.mirror.mirrors,
+ stats->n_packets, stats->n_bytes);
+ break;
+ case XC_LEARN:
+ ofproto_dpif_flow_mod(entry->u.learn.ofproto, entry->u.learn.fm);
+ break;
+ case XC_NORMAL:
+ xlate_cache_normal(entry->u.normal.ofproto, entry->u.normal.flow,
+ entry->u.normal.vlan);
+ break;
+ case XC_FIN_TIMEOUT:
+ xlate_fin_timeout__(entry->u.fin.rule, stats->tcp_flags,
+ entry->u.fin.idle, entry->u.fin.hard);
+ break;
+ case XC_GROUP:
+ group_dpif_credit_stats(entry->u.group.group, entry->u.group.bucket,
+ stats);
+ break;
+ case XC_TNL_ARP:
+ /* Lookup arp to avoid arp timeout. */
+ tnl_arp_lookup(entry->u.tnl_arp_cache.br_name, entry->u.tnl_arp_cache.d_ip, dmac);
+ break;
+ default:
+ OVS_NOT_REACHED();
+ }
+ }
+}
+
+static void
+xlate_dev_unref(struct xc_entry *entry)
+{
+ if (entry->u.dev.tx) {
+ netdev_close(entry->u.dev.tx);
+ }
+ if (entry->u.dev.rx) {
+ netdev_close(entry->u.dev.rx);
+ }
+ if (entry->u.dev.bfd) {
+ bfd_unref(entry->u.dev.bfd);
+ }
+}
+
+static void
+xlate_cache_clear_netflow(struct netflow *netflow, struct flow *flow)
+{
+ netflow_flow_clear(netflow, flow);
+ netflow_unref(netflow);
+ free(flow);
+}
+
+void
+xlate_cache_clear(struct xlate_cache *xcache)
+{
+ struct xc_entry *entry;
+ struct ofpbuf entries;
+
+ if (!xcache) {
+ return;
+ }
+
+ XC_ENTRY_FOR_EACH (entry, entries, xcache) {
+ switch (entry->type) {
+ case XC_RULE:
+ rule_dpif_unref(entry->u.rule);
+ break;
+ case XC_BOND:
+ free(entry->u.bond.flow);
+ bond_unref(entry->u.bond.bond);
+ break;
+ case XC_NETDEV:
+ xlate_dev_unref(entry);
+ break;
+ case XC_NETFLOW:
+ xlate_cache_clear_netflow(entry->u.nf.netflow, entry->u.nf.flow);
+ break;
+ case XC_MIRROR:
+ mbridge_unref(entry->u.mirror.mbridge);
+ break;
+ case XC_LEARN:
+ free(entry->u.learn.fm);
+ ofpbuf_delete(entry->u.learn.ofpacts);
+ break;
+ case XC_NORMAL:
+ free(entry->u.normal.flow);
+ break;
+ case XC_FIN_TIMEOUT:
+ /* 'u.fin.rule' is always already held as a XC_RULE, which
+ * has already released it's reference above. */
+ break;
+ case XC_GROUP:
+ group_dpif_unref(entry->u.group.group);
+ break;
+ case XC_TNL_ARP:
+ break;
+ default:
+ OVS_NOT_REACHED();
+ }
+ }
+
+ ofpbuf_clear(&xcache->entries);
+}
+
+void
+xlate_cache_delete(struct xlate_cache *xcache)
+{
+ xlate_cache_clear(xcache);
+ ofpbuf_uninit(&xcache->entries);
+ free(xcache);
+}
projects / cascardo / ovs.git / blobdiff