#include <netinet/in.h>
#include <stdbool.h>
#include <stdlib.h>
+#include "autopath.h"
+#include "bitmap.h"
+#include "bond.h"
#include "byte-order.h"
#include "cfm.h"
#include "classifier.h"
#include "fail-open.h"
#include "hash.h"
#include "hmap.h"
+#include "hmapx.h"
#include "in-band.h"
+#include "lacp.h"
#include "mac-learning.h"
#include "multipath.h"
#include "netdev.h"
#include "pinsched.h"
#include "pktbuf.h"
#include "poll-loop.h"
+#include "private.h"
#include "rconn.h"
#include "shash.h"
+#include "sset.h"
#include "stream-ssl.h"
-#include "svec.h"
#include "tag.h"
+#include "timer.h"
#include "timeval.h"
#include "unaligned.h"
#include "unixctl.h"
#include "vconn.h"
+#include "vlan-bitmap.h"
#include "vlog.h"
VLOG_DEFINE_THIS_MODULE(ofproto);
struct rule;
+#define MAX_MIRRORS 32
+typedef uint32_t mirror_mask_t;
+#define MIRROR_MASK_C(X) UINT32_C(X)
+BUILD_ASSERT_DECL(sizeof(mirror_mask_t) * CHAR_BIT >= MAX_MIRRORS);
+struct ofmirror {
+ struct ofproto *ofproto; /* Owning ofproto. */
+ size_t idx; /* In ofproto's "mirrors" array. */
+ void *aux; /* Key supplied by ofproto's client. */
+ char *name; /* Identifier for log messages. */
+
+ /* Selection criteria. */
+ struct hmapx srcs; /* Contains "struct ofbundle *"s. */
+ struct hmapx dsts; /* Contains "struct ofbundle *"s. */
+ unsigned long *vlans; /* Bitmap of chosen VLANs, NULL selects all. */
+
+ /* Output (mutually exclusive). */
+ struct ofbundle *out; /* Output port or NULL. */
+ int out_vlan; /* Output VLAN or -1. */
+};
+
+static void ofproto_mirror_destroy(struct ofmirror *);
+
+/* A group of one or more OpenFlow ports. */
+#define OFBUNDLE_FLOOD ((struct ofbundle *) 1)
+struct ofbundle {
+ struct ofproto *ofproto; /* Owning ofproto. */
+ struct hmap_node hmap_node; /* In struct ofproto's "bundles" hmap. */
+ void *aux; /* Key supplied by ofproto's client. */
+ char *name; /* Identifier for log messages. */
+
+ /* Configuration. */
+ struct list ports; /* Contains "struct ofport"s. */
+ int vlan; /* -1=trunk port, else a 12-bit VLAN ID. */
+ unsigned long *trunks; /* Bitmap of trunked VLANs, if 'vlan' == -1.
+ * NULL if all VLANs are trunked. */
+ struct lacp *lacp; /* LACP if LACP is enabled, otherwise NULL. */
+ struct bond *bond; /* Bonding setup if more than one port,
+ * otherwise NULL. */
+
+ /* Status. */
+ bool floodable; /* True if no port has OFPPC_NO_FLOOD set. */
+
+ /* Port mirroring info. */
+ mirror_mask_t src_mirrors; /* Mirrors triggered when packet received. */
+ mirror_mask_t dst_mirrors; /* Mirrors triggered when packet sent. */
+ mirror_mask_t mirror_out; /* Mirrors that output to this bundle. */
+};
+
+/* An OpenFlow port. */
struct ofport {
+ struct ofproto *ofproto; /* Owning ofproto. */
struct hmap_node hmap_node; /* In struct ofproto's "ports" hmap. */
struct netdev *netdev;
- struct ofp_phy_port opp; /* In host byte order. */
+ struct ofp_phy_port opp;
uint16_t odp_port;
+
+ /* Bridging. */
+ struct ofbundle *bundle; /* Bundle that contains this port, if any. */
+ struct list bundle_node; /* In struct ofbundle's "ports" list. */
struct cfm *cfm; /* Connectivity Fault Management, if any. */
+ tag_type tag; /* Tag associated with this port. */
};
static void ofport_free(struct ofport *);
-static void ofport_run(struct ofproto *, struct ofport *);
+static void ofport_run(struct ofport *);
static void ofport_wait(struct ofport *);
struct action_xlate_ctx {
* be reassessed for every packet. */
size_t actions_len; /* Number of bytes in actions[]. */
struct nlattr *actions; /* Datapath actions. */
- tag_type tags; /* Tags (set only by hooks). */
+ tag_type tags; /* Tags. */
struct netflow_flow nf_flow; /* Per-flow NetFlow tracking data. */
};
const struct flow *, bool clone);
struct ofproto {
+ char *name; /* Datapath name. */
+ struct hmap_node hmap_node; /* In global 'all_ofprotos' hmap. */
+
/* Settings. */
uint64_t datapath_id; /* Datapath ID. */
uint64_t fallback_dpid; /* Datapath ID if no better choice found. */
struct shash port_by_name;
uint32_t max_ports;
- /* Configuration. */
+ /* Bridging. */
struct netflow *netflow;
struct ofproto_sflow *sflow;
+ struct hmap bundles; /* Contains "struct ofbundle"s. */
+ struct mac_learning *ml;
+ struct ofmirror *mirrors[MAX_MIRRORS];
+ bool has_bonded_bundles;
/* Flow table. */
struct classifier cls;
- long long int next_expiration;
+ struct timer next_expiration;
/* Facets. */
struct hmap facets;
/* OpenFlow connections. */
struct connmgr *connmgr;
-
- /* Hooks for ovs-vswitchd. */
- const struct ofhooks *ofhooks;
- void *aux;
-
- /* Used by default ofhooks. */
- struct mac_learning *ml;
};
/* Map from dpif name to struct ofproto, for use by unixctl commands. */
-static struct shash all_ofprotos = SHASH_INITIALIZER(&all_ofprotos);
+static struct hmap all_ofprotos = HMAP_INITIALIZER(&all_ofprotos);
static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
-static const struct ofhooks default_ofhooks;
-
static uint64_t pick_datapath_id(const struct ofproto *);
static uint64_t pick_fallback_dpid(void);
+static void ofproto_flush_flows__(struct ofproto *);
static int ofproto_expire(struct ofproto *);
static void flow_push_stats(struct ofproto *, const struct rule *,
struct flow *, uint64_t packets, uint64_t bytes,
static int init_ports(struct ofproto *);
static void reinit_ports(struct ofproto *);
+static void update_learning_table(struct ofproto *,
+ const struct flow *, int vlan,
+ struct ofbundle *);
+static bool is_admissible(struct ofproto *, const struct flow *,
+ bool have_packet, tag_type *, int *vlanp,
+ struct ofbundle **in_bundlep);
+
static void ofproto_unixctl_init(void);
int
ofproto_create(const char *datapath, const char *datapath_type,
- const struct ofhooks *ofhooks, void *aux,
struct ofproto **ofprotop)
{
char local_name[IF_NAMESIZE];
struct ofproto *p;
struct dpif *dpif;
int error;
+ int i;
*ofprotop = NULL;
ofproto_unixctl_init();
/* Connect to datapath and start listening for messages. */
- error = dpif_open(datapath, datapath_type, &dpif);
+ error = dpif_create_and_open(datapath, datapath_type, &dpif);
if (error) {
VLOG_ERR("failed to open datapath %s: %s", datapath, strerror(error));
return error;
/* Initialize settings. */
p = xzalloc(sizeof *p);
+ p->name = xstrdup(dpif_name(dpif));
+ hmap_insert(&all_ofprotos, &p->hmap_node, hash_string(p->name, 0));
p->fallback_dpid = pick_fallback_dpid();
p->datapath_id = p->fallback_dpid;
p->mfr_desc = xstrdup(DEFAULT_MFR_DESC);
shash_init(&p->port_by_name);
p->max_ports = dpif_get_max_ports(dpif);
- /* Initialize submodules. */
+ /* Initialize bridging. */
p->netflow = NULL;
p->sflow = NULL;
+ hmap_init(&p->bundles);
+ p->ml = mac_learning_create();
+ for (i = 0; i < MAX_MIRRORS; i++) {
+ p->mirrors[i] = NULL;
+ }
+ p->has_bonded_bundles = false;
/* Initialize flow table. */
classifier_init(&p->cls);
- p->next_expiration = time_msec() + 1000;
+ timer_set_duration(&p->next_expiration, 1000);
/* Initialize facet table. */
hmap_init(&p->facets);
p->need_revalidate = false;
tag_set_init(&p->revalidate_set);
- /* Initialize hooks. */
- if (ofhooks) {
- p->ofhooks = ofhooks;
- p->aux = aux;
- p->ml = NULL;
- } else {
- p->ofhooks = &default_ofhooks;
- p->aux = p;
- p->ml = mac_learning_create();
- }
-
/* Pick final datapath ID. */
p->datapath_id = pick_datapath_id(p);
VLOG_INFO("using datapath ID %016"PRIx64, p->datapath_id);
- shash_add_once(&all_ofprotos, dpif_name(p->dpif), p);
-
/* Initialize OpenFlow connections. */
p->connmgr = connmgr_create(p, datapath, local_name);
+ init_ports(p);
+
*ofprotop = p;
return 0;
}
}
int
-ofproto_set_snoops(struct ofproto *ofproto, const struct svec *snoops)
+ofproto_set_snoops(struct ofproto *ofproto, const struct sset *snoops)
{
return connmgr_set_snoops(ofproto->connmgr, snoops);
}
ofproto_set_netflow(struct ofproto *ofproto,
const struct netflow_options *nf_options)
{
- if (nf_options && nf_options->collectors.n) {
+ if (nf_options && !sset_is_empty(&nf_options->collectors)) {
if (!ofproto->netflow) {
ofproto->netflow = netflow_create();
}
/* Clears the CFM configuration from 'port_no' on 'ofproto'. */
void
-ofproto_iface_clear_cfm(struct ofproto *ofproto, uint32_t port_no)
+ofproto_port_clear_cfm(struct ofproto *ofproto, uint32_t port_no)
{
struct ofport *ofport = get_port(ofproto, port_no);
if (ofport && ofport->cfm){
*
* This function has no effect if 'ofproto' does not have a port 'port_no'. */
void
-ofproto_iface_set_cfm(struct ofproto *ofproto, uint32_t port_no,
- const struct cfm *cfm,
- const uint16_t *remote_mps, size_t n_remote_mps)
+ofproto_port_set_cfm(struct ofproto *ofproto, uint32_t port_no,
+ const struct cfm *cfm,
+ const uint16_t *remote_mps, size_t n_remote_mps)
{
struct ofport *ofport;
ofport = get_port(ofproto, port_no);
if (!ofport) {
VLOG_WARN("%s: cannot configure CFM on nonexistent port %"PRIu32,
- dpif_name(ofproto->dpif), port_no);
+ ofproto->name, port_no);
return;
}
if (!cfm_configure(ofport->cfm)) {
VLOG_WARN("%s: CFM configuration on port %"PRIu32" (%s) failed",
- dpif_name(ofproto->dpif), port_no,
+ ofproto->name, port_no,
netdev_get_name(ofport->netdev));
cfm_destroy(ofport->cfm);
ofport->cfm = NULL;
* 'port_no' or if that port does not have CFM configured. The caller must not
* modify or destroy the returned object. */
const struct cfm *
-ofproto_iface_get_cfm(struct ofproto *ofproto, uint32_t port_no)
+ofproto_port_get_cfm(struct ofproto *ofproto, uint32_t port_no)
{
struct ofport *ofport = get_port(ofproto, port_no);
return ofport ? ofport->cfm : NULL;
}
+
+/* Checks the status of LACP negotiation for 'ofp_port' within ofproto.
+ * Returns 1 if LACP partner information for 'ofp_port' is up-to-date,
+ * 0 if LACP partner information is not current (generally indicating a
+ * connectivity problem), or -1 if LACP is not enabled on 'ofp_port'. */
+int
+ofproto_port_is_lacp_current(struct ofproto *ofproto, uint16_t ofp_port)
+{
+ struct ofport *ofport = get_port(ofproto, ofp_port_to_odp_port(ofp_port));
+ return (ofport && ofport->bundle && ofport->bundle->lacp
+ ? lacp_slave_is_current(ofport->bundle->lacp, ofport)
+ : -1);
+}
\f
-uint64_t
-ofproto_get_datapath_id(const struct ofproto *ofproto)
+/* Bundles. */
+
+/* Expires all MAC learning entries associated with 'port' and forces ofproto
+ * to revalidate every flow. */
+static void
+ofproto_bundle_flush_macs(struct ofbundle *bundle)
{
- return ofproto->datapath_id;
+ struct ofproto *ofproto = bundle->ofproto;
+ struct mac_learning *ml = ofproto->ml;
+ struct mac_entry *mac, *next_mac;
+
+ ofproto->need_revalidate = true;
+ LIST_FOR_EACH_SAFE (mac, next_mac, lru_node, &ml->lrus) {
+ if (mac->port.p == bundle) {
+ mac_learning_expire(ml, mac);
+ }
+ }
}
-bool
-ofproto_has_primary_controller(const struct ofproto *ofproto)
+static struct ofbundle *
+ofproto_bundle_lookup(const struct ofproto *ofproto, void *aux)
+{
+ struct ofbundle *bundle;
+
+ HMAP_FOR_EACH_IN_BUCKET (bundle, hmap_node, hash_pointer(aux, 0),
+ &ofproto->bundles) {
+ if (bundle->aux == aux) {
+ return bundle;
+ }
+ }
+ return NULL;
+}
+
+/* Looks up each of the 'n_auxes' pointers in 'auxes' as bundles and adds the
+ * ones that are found to 'bundles'. */
+static void
+ofproto_bundle_lookup_multiple(struct ofproto *ofproto,
+ void **auxes, size_t n_auxes,
+ struct hmapx *bundles)
+{
+ size_t i;
+
+ hmapx_init(bundles);
+ for (i = 0; i < n_auxes; i++) {
+ struct ofbundle *bundle = ofproto_bundle_lookup(ofproto, auxes[i]);
+ if (bundle) {
+ hmapx_add(bundles, bundle);
+ }
+ }
+}
+
+static void
+ofproto_bundle_del_port(struct ofport *port)
+{
+ struct ofbundle *bundle = port->bundle;
+
+ list_remove(&port->bundle_node);
+ port->bundle = NULL;
+
+ if (bundle->lacp) {
+ lacp_slave_unregister(bundle->lacp, port);
+ }
+ if (bundle->bond) {
+ bond_slave_unregister(bundle->bond, port);
+ }
+
+ bundle->floodable = true;
+ LIST_FOR_EACH (port, bundle_node, &bundle->ports) {
+ if (port->opp.config & htonl(OFPPC_NO_FLOOD)) {
+ bundle->floodable = false;
+ }
+ }
+}
+
+static bool
+ofproto_bundle_add_port(struct ofbundle *bundle, uint32_t ofp_port,
+ struct lacp_slave_settings *lacp)
+{
+ struct ofport *port;
+
+ port = get_port(bundle->ofproto, ofp_port_to_odp_port(ofp_port));
+ if (!port) {
+ return false;
+ }
+
+ if (port->bundle != bundle) {
+ if (port->bundle) {
+ ofproto_bundle_del_port(port);
+ }
+
+ port->bundle = bundle;
+ list_push_back(&bundle->ports, &port->bundle_node);
+ if (port->opp.config & htonl(OFPPC_NO_FLOOD)) {
+ bundle->floodable = false;
+ }
+ }
+
+ if (lacp) {
+ lacp_slave_register(bundle->lacp, port, lacp);
+ }
+
+ return true;
+}
+
+void
+ofproto_bundle_register(struct ofproto *ofproto, void *aux,
+ const struct ofproto_bundle_settings *s)
+{
+ bool need_flush = false;
+ const unsigned long *trunks;
+ struct ofbundle *bundle;
+ struct ofport *port;
+ size_t i;
+ bool ok;
+
+ assert(s->n_slaves == 1 || s->bond != NULL);
+ assert((s->lacp != NULL) == (s->lacp_slaves != NULL));
+
+ bundle = ofproto_bundle_lookup(ofproto, aux);
+ if (!bundle) {
+ bundle = xmalloc(sizeof *bundle);
+
+ bundle->ofproto = ofproto;
+ hmap_insert(&ofproto->bundles, &bundle->hmap_node,
+ hash_pointer(aux, 0));
+ bundle->aux = aux;
+ bundle->name = NULL;
+
+ list_init(&bundle->ports);
+ bundle->vlan = -1;
+ bundle->trunks = NULL;
+ bundle->bond = NULL;
+ bundle->lacp = NULL;
+
+ bundle->floodable = true;
+
+ bundle->src_mirrors = 0;
+ bundle->dst_mirrors = 0;
+ bundle->mirror_out = 0;
+ }
+
+ if (!bundle->name || strcmp(s->name, bundle->name)) {
+ free(bundle->name);
+ bundle->name = xstrdup(s->name);
+ }
+
+ /* LACP. */
+ if (s->lacp) {
+ if (!bundle->lacp) {
+ bundle->lacp = lacp_create();
+ }
+ lacp_configure(bundle->lacp, s->lacp);
+ } else {
+ lacp_destroy(bundle->lacp);
+ bundle->lacp = NULL;
+ }
+
+ /* Update set of ports. */
+ ok = true;
+ for (i = 0; i < s->n_slaves; i++) {
+ if (!ofproto_bundle_add_port(bundle, s->slaves[i],
+ s->lacp ? &s->lacp_slaves[i] : NULL)) {
+ ok = false;
+ }
+ }
+ if (!ok || list_size(&bundle->ports) != s->n_slaves) {
+ struct ofport *next_port;
+
+ LIST_FOR_EACH_SAFE (port, next_port, bundle_node, &bundle->ports) {
+ for (i = 0; i < s->n_slaves; i++) {
+ if (s->slaves[i] == odp_port_to_ofp_port(port->odp_port)) {
+ goto found;
+ }
+ }
+
+ ofproto_bundle_del_port(port);
+ found: ;
+ }
+ }
+ assert(list_size(&bundle->ports) <= s->n_slaves);
+
+ if (list_is_empty(&bundle->ports)) {
+ ofproto_bundle_unregister(ofproto, aux);
+ return;
+ }
+
+ /* Set VLAN tag. */
+ if (s->vlan != bundle->vlan) {
+ bundle->vlan = s->vlan;
+ need_flush = true;
+ }
+
+ /* Get trunked VLANs. */
+ trunks = s->vlan == -1 ? NULL : s->trunks;
+ if (!vlan_bitmap_equal(trunks, bundle->trunks)) {
+ free(bundle->trunks);
+ bundle->trunks = vlan_bitmap_clone(trunks);
+ need_flush = true;
+ }
+
+ /* Bonding. */
+ if (!list_is_short(&bundle->ports)) {
+ bundle->ofproto->has_bonded_bundles = true;
+ if (bundle->bond) {
+ if (bond_reconfigure(bundle->bond, s->bond)) {
+ ofproto->need_revalidate = true;
+ }
+ } else {
+ bundle->bond = bond_create(s->bond);
+ }
+
+ LIST_FOR_EACH (port, bundle_node, &bundle->ports) {
+ uint16_t stable_id = (bundle->lacp
+ ? lacp_slave_get_port_id(bundle->lacp, port)
+ : port->odp_port);
+ bond_slave_register(bundle->bond, port, stable_id, port->netdev);
+ }
+ } else {
+ bond_destroy(bundle->bond);
+ bundle->bond = NULL;
+ }
+
+ /* If we changed something that would affect MAC learning, un-learn
+ * everything on this port and force flow revalidation. */
+ if (need_flush) {
+ ofproto_bundle_flush_macs(bundle);
+ }
+}
+
+static void
+ofproto_bundle_destroy(struct ofbundle *bundle)
+{
+ struct ofproto *ofproto;
+ struct ofport *port, *next_port;
+ int i;
+
+ if (!bundle) {
+ return;
+ }
+
+ ofproto = bundle->ofproto;
+ for (i = 0; i < MAX_MIRRORS; i++) {
+ struct ofmirror *m = ofproto->mirrors[i];
+ if (m) {
+ if (m->out == bundle) {
+ ofproto_mirror_destroy(m);
+ } else if (hmapx_find_and_delete(&m->srcs, bundle)
+ || hmapx_find_and_delete(&m->dsts, bundle)) {
+ ofproto->need_revalidate = true;
+ }
+ }
+ }
+
+ LIST_FOR_EACH_SAFE (port, next_port, bundle_node, &bundle->ports) {
+ ofproto_bundle_del_port(port);
+ }
+
+ ofproto_bundle_flush_macs(bundle);
+ hmap_remove(&ofproto->bundles, &bundle->hmap_node);
+ free(bundle->name);
+ free(bundle->trunks);
+ bond_destroy(bundle->bond);
+ lacp_destroy(bundle->lacp);
+ free(bundle);
+}
+
+void
+ofproto_bundle_unregister(struct ofproto *ofproto, void *aux)
+{
+ ofproto_bundle_destroy(ofproto_bundle_lookup(ofproto, aux));
+}
+
+static void
+send_pdu_cb(void *port_, const struct lacp_pdu *pdu)
+{
+ static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 10);
+ struct ofport *port = port_;
+ uint8_t ea[ETH_ADDR_LEN];
+ int error;
+
+ error = netdev_get_etheraddr(port->netdev, ea);
+ if (!error) {
+ struct lacp_pdu *packet_pdu;
+ struct ofpbuf packet;
+
+ ofpbuf_init(&packet, 0);
+ packet_pdu = eth_compose(&packet, eth_addr_lacp, ea, ETH_TYPE_LACP,
+ sizeof *packet_pdu);
+ *packet_pdu = *pdu;
+ error = netdev_send(port->netdev, &packet);
+ if (error) {
+ VLOG_WARN_RL(&rl, "port %s: sending LACP PDU on iface %s failed "
+ "(%s)", port->bundle->name,
+ netdev_get_name(port->netdev), strerror(error));
+ }
+ ofpbuf_uninit(&packet);
+ } else {
+ VLOG_ERR_RL(&rl, "port %s: cannot obtain Ethernet address of iface "
+ "%s (%s)", port->bundle->name,
+ netdev_get_name(port->netdev), strerror(error));
+ }
+}
+
+static void
+ofproto_bundle_send_learning_packets(struct ofbundle *bundle)
+{
+ struct ofproto *ofproto = bundle->ofproto;
+ int error, n_packets, n_errors;
+ struct mac_entry *e;
+
+ error = n_packets = n_errors = 0;
+ LIST_FOR_EACH (e, lru_node, &ofproto->ml->lrus) {
+ if (e->port.p != bundle) {
+ int ret = bond_send_learning_packet(bundle->bond, e->mac, e->vlan);
+ if (ret) {
+ error = ret;
+ n_errors++;
+ }
+ n_packets++;
+ }
+ }
+
+ if (n_errors) {
+ static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
+ VLOG_WARN_RL(&rl, "bond %s: %d errors sending %d gratuitous learning "
+ "packets, last error was: %s",
+ bundle->name, n_errors, n_packets, strerror(error));
+ } else {
+ VLOG_DBG("bond %s: sent %d gratuitous learning packets",
+ bundle->name, n_packets);
+ }
+}
+
+static void
+ofproto_bundle_run(struct ofbundle *bundle)
+{
+ if (bundle->lacp) {
+ lacp_run(bundle->lacp, send_pdu_cb);
+ }
+ if (bundle->bond) {
+ struct ofport *port;
+
+ LIST_FOR_EACH (port, bundle_node, &bundle->ports) {
+ bool may_enable = lacp_slave_may_enable(bundle->lacp, port);
+ bond_slave_set_lacp_may_enable(bundle->bond, port, may_enable);
+ }
+
+ bond_run(bundle->bond, &bundle->ofproto->revalidate_set,
+ lacp_negotiated(bundle->lacp));
+ if (bond_should_send_learning_packets(bundle->bond)) {
+ ofproto_bundle_send_learning_packets(bundle);
+ }
+ }
+}
+
+static void
+ofproto_bundle_wait(struct ofbundle *bundle)
+{
+ if (bundle->lacp) {
+ lacp_wait(bundle->lacp);
+ }
+ if (bundle->bond) {
+ bond_wait(bundle->bond);
+ }
+}
+\f
+static int
+ofproto_mirror_scan(struct ofproto *ofproto)
+{
+ int idx;
+
+ for (idx = 0; idx < MAX_MIRRORS; idx++) {
+ if (!ofproto->mirrors[idx]) {
+ return idx;
+ }
+ }
+ return -1;
+}
+
+static struct ofmirror *
+ofproto_mirror_lookup(struct ofproto *ofproto, void *aux)
+{
+ int i;
+
+ for (i = 0; i < MAX_MIRRORS; i++) {
+ struct ofmirror *mirror = ofproto->mirrors[i];
+ if (mirror && mirror->aux == aux) {
+ return mirror;
+ }
+ }
+
+ return NULL;
+}
+
+void
+ofproto_mirror_register(struct ofproto *ofproto, void *aux,
+ const struct ofproto_mirror_settings *s)
+{
+ mirror_mask_t mirror_bit;
+ struct ofbundle *bundle;
+ struct ofmirror *mirror;
+ struct ofbundle *out;
+ struct hmapx srcs; /* Contains "struct ofbundle *"s. */
+ struct hmapx dsts; /* Contains "struct ofbundle *"s. */
+ int out_vlan;
+
+ mirror = ofproto_mirror_lookup(ofproto, aux);
+ if (!mirror) {
+ int idx;
+
+ idx = ofproto_mirror_scan(ofproto);
+ if (idx < 0) {
+ VLOG_WARN("bridge %s: maximum of %d port mirrors reached, "
+ "cannot create %s",
+ ofproto->name, MAX_MIRRORS, s->name);
+ return;
+ }
+
+ mirror = ofproto->mirrors[idx] = xzalloc(sizeof *mirror);
+ mirror->ofproto = ofproto;
+ mirror->idx = idx;
+ mirror->out_vlan = -1;
+ mirror->name = NULL;
+ }
+
+ if (!mirror->name || strcmp(s->name, mirror->name)) {
+ free(mirror->name);
+ mirror->name = xstrdup(s->name);
+ }
+
+ /* Get the new configuration. */
+ if (s->out_bundle) {
+ out = ofproto_bundle_lookup(ofproto, s->out_bundle);
+ if (!out) {
+ ofproto_mirror_destroy(mirror);
+ return;
+ }
+ out_vlan = -1;
+ } else {
+ out = NULL;
+ out_vlan = s->out_vlan;
+ }
+ ofproto_bundle_lookup_multiple(ofproto, s->srcs, s->n_srcs, &srcs);
+ ofproto_bundle_lookup_multiple(ofproto, s->dsts, s->n_dsts, &dsts);
+
+ /* If the configuration has not changed, do nothing. */
+ if (hmapx_equals(&srcs, &mirror->srcs)
+ && hmapx_equals(&dsts, &mirror->dsts)
+ && vlan_bitmap_equal(mirror->vlans, s->src_vlans)
+ && mirror->out == out
+ && mirror->out_vlan == out_vlan)
+ {
+ hmapx_destroy(&srcs);
+ hmapx_destroy(&dsts);
+ return;
+ }
+
+ hmapx_swap(&srcs, &mirror->srcs);
+ hmapx_destroy(&srcs);
+
+ hmapx_swap(&dsts, &mirror->dsts);
+ hmapx_destroy(&dsts);
+
+ free(mirror->vlans);
+ mirror->vlans = vlan_bitmap_clone(s->src_vlans);
+
+ mirror->out = out;
+ mirror->out_vlan = out_vlan;
+
+ /* Update bundles. */
+ mirror_bit = MIRROR_MASK_C(1) << mirror->idx;
+ HMAP_FOR_EACH (bundle, hmap_node, &mirror->ofproto->bundles) {
+ if (hmapx_contains(&mirror->srcs, bundle)) {
+ bundle->src_mirrors |= mirror_bit;
+ } else {
+ bundle->src_mirrors &= ~mirror_bit;
+ }
+
+ if (hmapx_contains(&mirror->dsts, bundle)) {
+ bundle->dst_mirrors |= mirror_bit;
+ } else {
+ bundle->dst_mirrors &= ~mirror_bit;
+ }
+
+ if (mirror->out == bundle) {
+ bundle->mirror_out |= mirror_bit;
+ } else {
+ bundle->mirror_out &= ~mirror_bit;
+ }
+ }
+
+ ofproto->need_revalidate = true;
+ mac_learning_flush(ofproto->ml);
+}
+
+static void
+ofproto_mirror_destroy(struct ofmirror *mirror)
+{
+ mirror_mask_t mirror_bit;
+ struct ofbundle *bundle;
+ struct ofproto *ofproto;
+
+ if (!mirror) {
+ return;
+ }
+
+ ofproto = mirror->ofproto;
+ ofproto->need_revalidate = true;
+ mac_learning_flush(ofproto->ml);
+
+ mirror_bit = MIRROR_MASK_C(1) << mirror->idx;
+ HMAP_FOR_EACH (bundle, hmap_node, &ofproto->bundles) {
+ bundle->src_mirrors &= ~mirror_bit;
+ bundle->dst_mirrors &= ~mirror_bit;
+ bundle->mirror_out &= ~mirror_bit;
+ }
+
+ hmapx_destroy(&mirror->srcs);
+ hmapx_destroy(&mirror->dsts);
+ free(mirror->vlans);
+
+ ofproto->mirrors[mirror->idx] = NULL;
+ free(mirror->name);
+ free(mirror);
+}
+
+void
+ofproto_mirror_unregister(struct ofproto *ofproto, void *aux)
+{
+ ofproto_mirror_destroy(ofproto_mirror_lookup(ofproto, aux));
+}
+
+void
+ofproto_set_flood_vlans(struct ofproto *ofproto, unsigned long *flood_vlans)
{
- return connmgr_has_controllers(ofproto->connmgr);
+ if (mac_learning_set_flood_vlans(ofproto->ml, flood_vlans)) {
+ ofproto->need_revalidate = true;
+ mac_learning_flush(ofproto->ml);
+ }
}
-enum ofproto_fail_mode
-ofproto_get_fail_mode(const struct ofproto *p)
+bool
+ofproto_is_mirror_output_bundle(struct ofproto *ofproto, void *aux)
+{
+ struct ofbundle *bundle = ofproto_bundle_lookup(ofproto, aux);
+ return bundle && bundle->mirror_out != 0;
+}
+\f
+bool
+ofproto_has_snoops(const struct ofproto *ofproto)
{
- return connmgr_get_fail_mode(p->connmgr);
+ return connmgr_has_snoops(ofproto->connmgr);
}
void
-ofproto_get_snoops(const struct ofproto *ofproto, struct svec *snoops)
+ofproto_get_snoops(const struct ofproto *ofproto, struct sset *snoops)
{
connmgr_get_snoops(ofproto->connmgr, snoops);
}
ofproto_destroy(struct ofproto *p)
{
struct ofport *ofport, *next_ofport;
+ int i;
if (!p) {
return;
}
- shash_find_and_delete(&all_ofprotos, dpif_name(p->dpif));
+ hmap_remove(&all_ofprotos, &p->hmap_node);
- ofproto_flush_flows(p);
+ for (i = 0; i < MAX_MIRRORS; i++) {
+ ofproto_mirror_destroy(p->mirrors[i]);
+ }
+ ofproto_flush_flows__(p);
connmgr_destroy(p->connmgr);
classifier_destroy(&p->cls);
hmap_destroy(&p->facets);
dpif_close(p->dpif);
+
netdev_monitor_destroy(p->netdev_monitor);
HMAP_FOR_EACH_SAFE (ofport, next_ofport, hmap_node, &p->ports) {
hmap_remove(&p->ports, &ofport->hmap_node);
netflow_destroy(p->netflow);
ofproto_sflow_destroy(p->sflow);
- mac_learning_destroy(p->ml);
-
free(p->mfr_desc);
free(p->hw_desc);
free(p->sw_desc);
hmap_destroy(&p->ports);
+ free(p->name);
free(p);
}
-int
-ofproto_run(struct ofproto *p)
-{
- int error = ofproto_run1(p);
- if (!error) {
- error = ofproto_run2(p, false);
- }
- return error;
-}
-
static void
process_port_change(struct ofproto *ofproto, int error, char *devname)
{
}
int
-ofproto_run1(struct ofproto *p)
+ofproto_run(struct ofproto *p)
{
+ struct ofbundle *bundle;
struct ofport *ofport;
char *devname;
int error;
int i;
- if (shash_is_empty(&p->port_by_name)) {
- init_ports(p);
- }
-
for (i = 0; i < 50; i++) {
struct dpif_upcall packet;
* spin from here on out. */
static struct vlog_rate_limit rl2 = VLOG_RATE_LIMIT_INIT(1, 5);
VLOG_ERR_RL(&rl2, "%s: datapath was destroyed externally",
- dpif_name(p->dpif));
+ p->name);
return ENODEV;
}
break;
}
HMAP_FOR_EACH (ofport, hmap_node, &p->ports) {
- ofport_run(p, ofport);
+ ofport_run(ofport);
+ }
+
+ HMAP_FOR_EACH (bundle, hmap_node, &p->bundles) {
+ ofproto_bundle_run(bundle);
}
connmgr_run(p->connmgr, handle_openflow);
- if (time_msec() >= p->next_expiration) {
+ if (timer_expired(&p->next_expiration)) {
int delay = ofproto_expire(p);
- p->next_expiration = time_msec() + delay;
+ timer_set_duration(&p->next_expiration, delay);
COVERAGE_INC(ofproto_expiration);
}
ofproto_sflow_run(p->sflow);
}
- return 0;
-}
-
-int
-ofproto_run2(struct ofproto *p, bool revalidate_all)
-{
- /* Figure out what we need to revalidate now, if anything. */
- struct tag_set revalidate_set = p->revalidate_set;
- if (p->need_revalidate) {
- revalidate_all = true;
- }
-
- /* Clear the revalidation flags. */
- tag_set_init(&p->revalidate_set);
- p->need_revalidate = false;
-
/* Now revalidate if there's anything to do. */
- if (revalidate_all || !tag_set_is_empty(&revalidate_set)) {
+ if (p->need_revalidate || !tag_set_is_empty(&p->revalidate_set)) {
+ struct tag_set revalidate_set = p->revalidate_set;
+ bool revalidate_all = p->need_revalidate;
struct facet *facet, *next;
+ /* Clear the revalidation flags. */
+ tag_set_init(&p->revalidate_set);
+ p->need_revalidate = false;
+
HMAP_FOR_EACH_SAFE (facet, next, hmap_node, &p->facets) {
if (revalidate_all
|| tag_set_intersects(&revalidate_set, facet->tags)) {
void
ofproto_wait(struct ofproto *p)
{
+ struct ofbundle *bundle;
struct ofport *ofport;
HMAP_FOR_EACH (ofport, hmap_node, &p->ports) {
ofport_wait(ofport);
}
+ HMAP_FOR_EACH (bundle, hmap_node, &p->bundles) {
+ ofproto_bundle_wait(bundle);
+ }
dpif_recv_wait(p->dpif);
dpif_port_poll_wait(p->dpif);
netdev_monitor_poll_wait(p->netdev_monitor);
/* Shouldn't happen, but if it does just go around again. */
VLOG_DBG_RL(&rl, "need revalidate in ofproto_wait_cb()");
poll_immediate_wake();
- } else if (p->next_expiration != LLONG_MAX) {
- poll_timer_wait_until(p->next_expiration);
+ } else {
+ timer_wait(&p->next_expiration);
}
connmgr_wait(p->connmgr);
}
-void
-ofproto_revalidate(struct ofproto *ofproto, tag_type tag)
-{
- tag_set_add(&ofproto->revalidate_set, tag);
-}
-
-struct tag_set *
-ofproto_get_revalidate_set(struct ofproto *ofproto)
-{
- return &ofproto->revalidate_set;
-}
-
bool
ofproto_is_alive(const struct ofproto *p)
{
shash_destroy(info);
}
-/* Deletes port number 'odp_port' from the datapath for 'ofproto'.
+/* Makes a deep copy of 'old' into 'port'. */
+void
+ofproto_port_clone(struct ofproto_port *port, const struct ofproto_port *old)
+{
+ port->name = xstrdup(old->name);
+ port->type = xstrdup(old->type);
+ port->ofp_port = old->ofp_port;
+}
+
+/* Frees memory allocated to members of 'ofproto_port'.
+ *
+ * Do not call this function on an ofproto_port obtained from
+ * ofproto_port_dump_next(): that function retains ownership of the data in the
+ * ofproto_port. */
+void
+ofproto_port_destroy(struct ofproto_port *ofproto_port)
+{
+ free(ofproto_port->name);
+ free(ofproto_port->type);
+}
+
+/* Converts a dpif_port into an ofproto_port.
+ *
+ * This only makes a shallow copy, so make sure that the dpif_port doesn't get
+ * freed while the ofproto_port is still in use. You can choose to free the
+ * ofproto_port instead of the dpif_port. */
+static void
+ofproto_port_from_dpif_port(struct ofproto_port *ofproto_port,
+ struct dpif_port *dpif_port)
+{
+ ofproto_port->name = dpif_port->name;
+ ofproto_port->type = dpif_port->type;
+ ofproto_port->ofp_port = odp_port_to_ofp_port(dpif_port->port_no);
+}
+
+/* Initializes 'dump' to begin dumping the ports in an ofproto.
+ *
+ * This function provides no status indication. An error status for the entire
+ * dump operation is provided when it is completed by calling
+ * ofproto_port_dump_done().
+ */
+void
+ofproto_port_dump_start(struct ofproto_port_dump *dump,
+ const struct ofproto *ofproto)
+{
+ struct dpif_port_dump *dpif_dump;
+
+ dump->state = dpif_dump = xmalloc(sizeof *dpif_dump);
+ dpif_port_dump_start(dpif_dump, ofproto->dpif);
+}
+
+/* Attempts to retrieve another port from 'dump', which must have been created
+ * with ofproto_port_dump_start(). On success, stores a new ofproto_port into
+ * 'port' and returns true. On failure, returns false.
+ *
+ * Failure might indicate an actual error or merely that the last port has been
+ * dumped. An error status for the entire dump operation is provided when it
+ * is completed by calling ofproto_port_dump_done().
+ *
+ * The ofproto owns the data stored in 'port'. It will remain valid until at
+ * least the next time 'dump' is passed to ofproto_port_dump_next() or
+ * ofproto_port_dump_done(). */
+bool
+ofproto_port_dump_next(struct ofproto_port_dump *dump,
+ struct ofproto_port *port)
+{
+ struct dpif_port_dump *dpif_dump = dump->state;
+ struct dpif_port dpif_port;
+ bool ok;
+
+ ok = dpif_port_dump_next(dpif_dump, &dpif_port);
+ if (ok) {
+ ofproto_port_from_dpif_port(port, &dpif_port);
+ }
+ return ok;
+}
+
+/* Completes port table dump operation 'dump', which must have been created
+ * with ofproto_port_dump_start(). Returns 0 if the dump operation was
+ * error-free, otherwise a positive errno value describing the problem. */
+int
+ofproto_port_dump_done(struct ofproto_port_dump *dump)
+{
+ struct dpif_port_dump *dpif_dump = dump->state;
+ int error = dpif_port_dump_done(dpif_dump);
+ free(dpif_dump);
+ return error;
+}
+
+/* Attempts to add 'netdev' as a port on 'ofproto'. If successful, returns 0
+ * and sets '*ofp_portp' to the new port's port OpenFlow number (if 'ofp_portp'
+ * is non-null). On failure, returns a positive errno value and sets
+ * '*ofp_portp' to OFPP_NONE (if 'ofp_portp' is non-null). */
+int
+ofproto_port_add(struct ofproto *ofproto, struct netdev *netdev,
+ uint16_t *ofp_portp)
+{
+ uint16_t odp_port;
+ int error;
+
+ error = dpif_port_add(ofproto->dpif, netdev, &odp_port);
+ if (!error) {
+ update_port(ofproto, netdev_get_name(netdev));
+ }
+ if (ofp_portp) {
+ *ofp_portp = error ? OFPP_NONE : odp_port_to_ofp_port(odp_port);
+ }
+ return error;
+}
+
+/* Looks up a port named 'devname' in 'ofproto'. On success, returns 0 and
+ * initializes '*port' appropriately; on failure, returns a positive errno
+ * value.
+ *
+ * The caller owns the data in 'port' and must free it with
+ * ofproto_port_destroy() when it is no longer needed. */
+int
+ofproto_port_query_by_name(const struct ofproto *ofproto, const char *devname,
+ struct ofproto_port *port)
+{
+ struct dpif_port dpif_port;
+ int error;
+
+ error = dpif_port_query_by_name(ofproto->dpif, devname, &dpif_port);
+ if (!error) {
+ ofproto_port_from_dpif_port(port, &dpif_port);
+ }
+ return error;
+}
+
+/* Deletes port number 'ofp_port' from the datapath for 'ofproto'.
*
* This is almost the same as calling dpif_port_del() directly on the
* datapath, but it also makes 'ofproto' close its open netdev for the port
*
* Returns 0 if successful, otherwise a positive errno. */
int
-ofproto_port_del(struct ofproto *ofproto, uint16_t odp_port)
+ofproto_port_del(struct ofproto *ofproto, uint16_t ofp_port)
{
+ uint32_t odp_port = ofp_port_to_odp_port(ofp_port);
struct ofport *ofport = get_port(ofproto, odp_port);
- const char *name = ofport ? ofport->opp.name : "<unknown>";
+ const char *name = ofport ? netdev_get_name(ofport->netdev) : "<unknown>";
int error;
error = dpif_port_del(ofproto->dpif, odp_port);
if (error) {
VLOG_ERR("%s: failed to remove port %"PRIu16" (%s) interface (%s)",
- dpif_name(ofproto->dpif), odp_port, name, strerror(error));
+ ofproto->name, odp_port, name, strerror(error));
} else if (ofport) {
- /* 'name' is ofport->opp.name and update_port() is going to destroy
- * 'ofport'. Just in case update_port() refers to 'name' after it
+ /* 'name' is the netdev's name and update_port() is going to close the
+ * netdev. Just in case update_port() refers to 'name' after it
* destroys 'ofport', make a copy of it around the update_port()
* call. */
char *devname = xstrdup(name);
return error;
}
-/* Checks if 'ofproto' thinks 'odp_port' should be included in floods. Returns
- * true if 'odp_port' exists and should be included, false otherwise. */
-bool
-ofproto_port_is_floodable(struct ofproto *ofproto, uint16_t odp_port)
-{
- struct ofport *ofport = get_port(ofproto, odp_port);
- return ofport && !(ofport->opp.config & OFPPC_NO_FLOOD);
-}
-
/* Sends 'packet' out of port 'port_no' within 'p'. If 'vlan_tci' is zero the
* packet will not have any 802.1Q hader; if it is nonzero, then the packet
* will be sent with the VLAN TCI specified by 'vlan_tci & ~VLAN_CFI'.
*
* Returns 0 if successful, otherwise a positive errno value. */
-int
+static int
ofproto_send_packet(struct ofproto *ofproto,
uint32_t port_no, uint16_t vlan_tci,
const struct ofpbuf *packet)
if (error) {
VLOG_WARN_RL(&rl, "%s: failed to send packet on port %"PRIu32" (%s)",
- dpif_name(ofproto->dpif), port_no, strerror(error));
+ ofproto->name, port_no, strerror(error));
}
return error;
}
}
}
-void
-ofproto_flush_flows(struct ofproto *ofproto)
+static void
+ofproto_flush_flows__(struct ofproto *ofproto)
{
struct facet *facet, *next_facet;
struct rule *rule, *next_rule;
}
dpif_flow_flush(ofproto->dpif);
+}
+
+void
+ofproto_flush_flows(struct ofproto *ofproto)
+{
+ ofproto_flush_flows__(ofproto);
connmgr_flushed(ofproto->connmgr);
}
\f
reinit_ports(struct ofproto *p)
{
struct dpif_port_dump dump;
- struct shash_node *node;
- struct shash devnames;
+ struct sset devnames;
struct ofport *ofport;
struct dpif_port dpif_port;
+ const char *devname;
COVERAGE_INC(ofproto_reinit_ports);
- shash_init(&devnames);
+ sset_init(&devnames);
HMAP_FOR_EACH (ofport, hmap_node, &p->ports) {
- shash_add_once (&devnames, ofport->opp.name, NULL);
+ sset_add(&devnames, netdev_get_name(ofport->netdev));
}
DPIF_PORT_FOR_EACH (&dpif_port, &dump, p->dpif) {
- shash_add_once (&devnames, dpif_port.name, NULL);
+ sset_add(&devnames, dpif_port.name);
}
- SHASH_FOR_EACH (node, &devnames) {
- update_port(p, node->name);
+ SSET_FOR_EACH (devname, &devnames) {
+ update_port(p, devname);
}
- shash_destroy(&devnames);
+ sset_destroy(&devnames);
}
-static struct ofport *
-make_ofport(const struct dpif_port *dpif_port)
+/* Opens and returns a netdev for 'dpif_port', or a null pointer if the netdev
+ * cannot be opened. On success, also fills in 'opp'. */
+static struct netdev *
+ofport_open(const struct dpif_port *dpif_port, struct ofp_phy_port *opp)
{
+ uint32_t curr, advertised, supported, peer;
struct netdev_options netdev_options;
enum netdev_flags flags;
- struct ofport *ofport;
struct netdev *netdev;
int error;
return NULL;
}
- ofport = xzalloc(sizeof *ofport);
- ofport->netdev = netdev;
- ofport->odp_port = dpif_port->port_no;
- ofport->opp.port_no = odp_port_to_ofp_port(dpif_port->port_no);
- netdev_get_etheraddr(netdev, ofport->opp.hw_addr);
- ovs_strlcpy(ofport->opp.name, dpif_port->name, sizeof ofport->opp.name);
-
netdev_get_flags(netdev, &flags);
- ofport->opp.config = flags & NETDEV_UP ? 0 : OFPPC_PORT_DOWN;
+ netdev_get_features(netdev, &curr, &advertised, &supported, &peer);
- ofport->opp.state = netdev_get_carrier(netdev) ? 0 : OFPPS_LINK_DOWN;
+ opp->port_no = htons(odp_port_to_ofp_port(dpif_port->port_no));
+ netdev_get_etheraddr(netdev, opp->hw_addr);
+ ovs_strzcpy(opp->name, dpif_port->name, sizeof opp->name);
+ opp->config = flags & NETDEV_UP ? 0 : htonl(OFPPC_PORT_DOWN);
+ opp->state = netdev_get_carrier(netdev) ? 0 : htonl(OFPPS_LINK_DOWN);
+ opp->curr = htonl(curr);
+ opp->advertised = htonl(advertised);
+ opp->supported = htonl(supported);
+ opp->peer = htonl(peer);
- netdev_get_features(netdev,
- &ofport->opp.curr, &ofport->opp.advertised,
- &ofport->opp.supported, &ofport->opp.peer);
- return ofport;
+ return netdev;
}
static bool
}
}
-static int
-ofport_equal(const struct ofport *a_, const struct ofport *b_)
+/* Returns true if most fields of 'a' and 'b' are equal. Differences in name,
+ * port number, and 'config' bits other than OFPPC_PORT_DOWN are
+ * disregarded. */
+static bool
+ofport_equal(const struct ofp_phy_port *a, const struct ofp_phy_port *b)
{
- const struct ofp_phy_port *a = &a_->opp;
- const struct ofp_phy_port *b = &b_->opp;
-
BUILD_ASSERT_DECL(sizeof *a == 48); /* Detect ofp_phy_port changes. */
- return (a->port_no == b->port_no
- && !memcmp(a->hw_addr, b->hw_addr, sizeof a->hw_addr)
- && !strcmp(a->name, b->name)
+ return (!memcmp(a->hw_addr, b->hw_addr, sizeof a->hw_addr)
&& a->state == b->state
- && a->config == b->config
+ && !((a->config ^ b->config) & htonl(OFPPC_PORT_DOWN))
&& a->curr == b->curr
&& a->advertised == b->advertised
&& a->supported == b->supported
&& a->peer == b->peer);
}
+/* Adds an ofport to 'p' initialized based on the given 'netdev' and 'opp'.
+ * The caller must ensure that 'p' does not have a conflicting ofport (that is,
+ * one with the same name or port number). */
static void
-ofport_install(struct ofproto *p, struct ofport *ofport)
+ofport_install(struct ofproto *p,
+ struct netdev *netdev, const struct ofp_phy_port *opp)
{
- const char *netdev_name = ofport->opp.name;
+ const char *netdev_name = netdev_get_name(netdev);
+ struct ofport *ofport;
+ connmgr_send_port_status(p->connmgr, opp, OFPPR_ADD);
+
+ /* Create ofport. */
+ ofport = xmalloc(sizeof *ofport);
+ ofport->ofproto = p;
+ ofport->netdev = netdev;
+ ofport->opp = *opp;
+ ofport->odp_port = ofp_port_to_odp_port(ntohs(opp->port_no));
+ ofport->bundle = NULL;
+ ofport->cfm = NULL;
+ ofport->tag = tag_create_random();
+
+ /* Add port to 'p'. */
netdev_monitor_add(p->netdev_monitor, ofport->netdev);
hmap_insert(&p->ports, &ofport->hmap_node, hash_int(ofport->odp_port, 0));
shash_add(&p->port_by_name, netdev_name, ofport);
}
}
+/* Removes 'ofport' from 'p' and destroys it. */
static void
-ofport_remove(struct ofproto *p, struct ofport *ofport)
+ofport_remove(struct ofport *ofport)
{
- netdev_monitor_remove(p->netdev_monitor, ofport->netdev);
- hmap_remove(&p->ports, &ofport->hmap_node);
- shash_delete(&p->port_by_name,
- shash_find(&p->port_by_name, ofport->opp.name));
- if (p->sflow) {
- ofproto_sflow_del_port(p->sflow, ofport->odp_port);
+ connmgr_send_port_status(ofport->ofproto->connmgr, &ofport->opp,
+ OFPPR_DELETE);
+ ofport_free(ofport);
+}
+
+/* If 'ofproto' contains an ofport named 'name', removes it from 'ofproto' and
+ * destroys it. */
+static void
+ofport_remove_with_name(struct ofproto *ofproto, const char *name)
+{
+ struct ofport *port = shash_find_data(&ofproto->port_by_name, name);
+ if (port) {
+ ofport_remove(port);
+ }
+}
+
+/* Updates 'port' within 'ofproto' with the new 'netdev' and 'opp'.
+ *
+ * Does not handle a name or port number change. The caller must implement
+ * such a change as a delete followed by an add. */
+static void
+ofport_modified(struct ofport *port,
+ struct netdev *netdev, struct ofp_phy_port *opp)
+{
+ struct ofproto *ofproto = port->ofproto;
+
+ if (port->bundle && port->bundle->bond) {
+ bond_slave_set_netdev(port->bundle->bond, port, netdev);
}
+
+ memcpy(port->opp.hw_addr, opp->hw_addr, ETH_ADDR_LEN);
+ port->opp.config = ((port->opp.config & ~htonl(OFPPC_PORT_DOWN))
+ | (opp->config & htonl(OFPPC_PORT_DOWN)));
+ port->opp.state = opp->state;
+ port->opp.curr = opp->curr;
+ port->opp.advertised = opp->advertised;
+ port->opp.supported = opp->supported;
+ port->opp.peer = opp->peer;
+
+ netdev_monitor_remove(ofproto->netdev_monitor, port->netdev);
+ netdev_monitor_add(ofproto->netdev_monitor, netdev);
+
+ netdev_close(port->netdev);
+ port->netdev = netdev;
+
+ connmgr_send_port_status(ofproto->connmgr, &port->opp, OFPPR_MODIFY);
}
static void
-ofport_run(struct ofproto *ofproto, struct ofport *ofport)
+ofport_run(struct ofport *ofport)
{
if (ofport->cfm) {
cfm_run(ofport->cfm);
struct ccm *ccm;
ofpbuf_init(&packet, 0);
- ccm = compose_packet(&packet, eth_addr_ccm, ofport->opp.hw_addr,
- ETH_TYPE_CFM, sizeof *ccm);
+ ccm = eth_compose(&packet, eth_addr_ccm, ofport->opp.hw_addr,
+ ETH_TYPE_CFM, sizeof *ccm);
cfm_compose_ccm(ofport->cfm, ccm);
- ofproto_send_packet(ofproto, ofport->odp_port, 0, &packet);
+ ofproto_send_packet(ofport->ofproto, ofport->odp_port, 0, &packet);
ofpbuf_uninit(&packet);
}
}
}
static void
-ofport_free(struct ofport *ofport)
+ofport_unregister(struct ofport *port)
{
- if (ofport) {
- cfm_destroy(ofport->cfm);
- netdev_close(ofport->netdev);
- free(ofport);
+ struct ofbundle *bundle = port->bundle;
+
+ if (bundle) {
+ ofproto_bundle_del_port(port);
+ if (list_is_empty(&bundle->ports)) {
+ ofproto_bundle_destroy(bundle);
+ } else if (list_is_short(&bundle->ports)) {
+ bond_destroy(bundle->bond);
+ bundle->bond = NULL;
+ }
+ }
+
+ cfm_destroy(port->cfm);
+ port->cfm = NULL;
+}
+
+void
+ofproto_port_unregister(struct ofproto *ofproto, uint32_t ofp_port)
+{
+ struct ofport *port = get_port(ofproto, ofp_port_to_odp_port(ofp_port));
+ if (port) {
+ ofport_unregister(port);
+ }
+}
+
+static void
+ofport_free(struct ofport *port)
+{
+ if (port) {
+ struct ofproto *ofproto = port->ofproto;
+ const char *name = netdev_get_name(port->netdev);
+
+ ofport_unregister(port);
+
+ netdev_monitor_remove(ofproto->netdev_monitor, port->netdev);
+ hmap_remove(&ofproto->ports, &port->hmap_node);
+ shash_delete(&ofproto->port_by_name,
+ shash_find(&ofproto->port_by_name, name));
+ if (ofproto->sflow) {
+ ofproto_sflow_del_port(ofproto->sflow, port->odp_port);
+ }
+
+ netdev_close(port->netdev);
+ free(port);
}
}
}
static void
-update_port(struct ofproto *p, const char *devname)
+update_port(struct ofproto *ofproto, const char *name)
{
struct dpif_port dpif_port;
- struct ofport *old_ofport;
- struct ofport *new_ofport;
- int error;
+ struct ofp_phy_port opp;
+ struct netdev *netdev;
+ struct ofport *port;
COVERAGE_INC(ofproto_update_port);
- /* Query the datapath for port information. */
- error = dpif_port_query_by_name(p->dpif, devname, &dpif_port);
-
- /* Find the old ofport. */
- old_ofport = shash_find_data(&p->port_by_name, devname);
- if (!error) {
- if (!old_ofport) {
- /* There's no port named 'devname' but there might be a port with
- * the same port number. This could happen if a port is deleted
- * and then a new one added in its place very quickly, or if a port
- * is renamed. In the former case we want to send an OFPPR_DELETE
- * and an OFPPR_ADD, and in the latter case we want to send a
- * single OFPPR_MODIFY. We can distinguish the cases by comparing
- * the old port's ifindex against the new port, or perhaps less
- * reliably but more portably by comparing the old port's MAC
- * against the new port's MAC. However, this code isn't that smart
- * and always sends an OFPPR_MODIFY (XXX). */
- old_ofport = get_port(p, dpif_port.port_no);
- }
- } else if (error != ENOENT && error != ENODEV) {
- VLOG_WARN_RL(&rl, "dpif_port_query_by_name returned unexpected error "
- "%s", strerror(error));
- goto exit;
- }
-
- /* Create a new ofport. */
- new_ofport = !error ? make_ofport(&dpif_port) : NULL;
-
- /* Eliminate a few pathological cases. */
- if (!old_ofport && !new_ofport) {
- goto exit;
- } else if (old_ofport && new_ofport) {
- /* Most of the 'config' bits are OpenFlow soft state, but
- * OFPPC_PORT_DOWN is maintained by the kernel. So transfer the
- * OpenFlow bits from old_ofport. (make_ofport() only sets
- * OFPPC_PORT_DOWN and leaves the other bits 0.) */
- new_ofport->opp.config |= old_ofport->opp.config & ~OFPPC_PORT_DOWN;
-
- if (ofport_equal(old_ofport, new_ofport)) {
- /* False alarm--no change. */
- ofport_free(new_ofport);
- goto exit;
+ /* Fetch 'name''s location and properties from the datapath. */
+ netdev = (!dpif_port_query_by_name(ofproto->dpif, name, &dpif_port)
+ ? ofport_open(&dpif_port, &opp)
+ : NULL);
+ if (netdev) {
+ port = get_port(ofproto, dpif_port.port_no);
+ if (port && !strcmp(netdev_get_name(port->netdev), name)) {
+ /* 'name' hasn't changed location. Any properties changed? */
+ if (!ofport_equal(&port->opp, &opp)) {
+ ofport_modified(port, netdev, &opp);
+ } else {
+ netdev_close(netdev);
+ }
+ } else {
+ /* If 'port' is nonnull then its name differs from 'name' and thus
+ * we should delete it. If we think there's a port named 'name'
+ * then its port number must be wrong now so delete it too. */
+ if (port) {
+ ofport_remove(port);
+ }
+ ofport_remove_with_name(ofproto, name);
+ ofport_install(ofproto, netdev, &opp);
}
+ } else {
+ /* Any port named 'name' is gone now. */
+ ofport_remove_with_name(ofproto, name);
}
-
- /* Now deal with the normal cases. */
- if (old_ofport) {
- ofport_remove(p, old_ofport);
- }
- if (new_ofport) {
- ofport_install(p, new_ofport);
- }
- connmgr_send_port_status(p->connmgr,
- new_ofport ? &new_ofport->opp : &old_ofport->opp,
- (!old_ofport ? OFPPR_ADD
- : !new_ofport ? OFPPR_DELETE
- : OFPPR_MODIFY));
- ofport_free(old_ofport);
-
-exit:
dpif_port_destroy(&dpif_port);
}
DPIF_PORT_FOR_EACH (&dpif_port, &dump, p->dpif) {
if (!ofport_conflicts(p, &dpif_port)) {
- struct ofport *ofport = make_ofport(&dpif_port);
- if (ofport) {
- ofport_install(p, ofport);
+ struct ofp_phy_port opp;
+ struct netdev *netdev;
+
+ netdev = ofport_open(&dpif_port, &opp);
+ if (netdev) {
+ ofport_install(p, netdev, &opp);
}
}
}
}
}
-/* Ensures that the bytes in 'facet', plus 'extra_bytes', have been passed up
- * to the accounting hook function in the ofhooks structure. */
static void
facet_account(struct ofproto *ofproto,
struct facet *facet, uint64_t extra_bytes)
{
- uint64_t total_bytes = facet->byte_count + extra_bytes;
+ uint64_t total_bytes, n_bytes;
+ struct ofbundle *in_bundle;
+ const struct nlattr *a;
+ tag_type dummy = 0;
+ unsigned int left;
+ int vlan;
- if (ofproto->ofhooks->account_flow_cb
- && total_bytes > facet->accounted_bytes)
- {
- ofproto->ofhooks->account_flow_cb(
- &facet->flow, facet->tags, facet->actions, facet->actions_len,
- total_bytes - facet->accounted_bytes, ofproto->aux);
- facet->accounted_bytes = total_bytes;
+ total_bytes = facet->byte_count + extra_bytes;
+ if (total_bytes <= facet->accounted_bytes) {
+ return;
+ }
+ n_bytes = total_bytes - facet->accounted_bytes;
+ facet->accounted_bytes = total_bytes;
+
+ /* Test that 'tags' is nonzero to ensure that only flows that include an
+ * OFPP_NORMAL action are used for learning and bond slave rebalancing.
+ * This works because OFPP_NORMAL always sets a nonzero tag value.
+ *
+ * Feed information from the active flows back into the learning table to
+ * ensure that table is always in sync with what is actually flowing
+ * through the datapath. */
+ if (!facet->tags
+ || !is_admissible(ofproto, &facet->flow, false, &dummy,
+ &vlan, &in_bundle)) {
+ return;
+ }
+
+ update_learning_table(ofproto, &facet->flow, vlan, in_bundle);
+
+ if (!ofproto->has_bonded_bundles) {
+ return;
+ }
+ NL_ATTR_FOR_EACH_UNSAFE (a, left, facet->actions, facet->actions_len) {
+ if (nl_attr_type(a) == ODP_ACTION_ATTR_OUTPUT) {
+ struct ofport *port = get_port(ofproto, nl_attr_get_u32(a));
+ if (port && port->bundle && port->bundle->bond) {
+ bond_account(port->bundle->bond, &facet->flow, vlan, n_bytes);
+ }
+ }
}
}
return true;
}
\f
+/* Bridge packet processing functions. */
+
+struct dst {
+ struct ofport *port;
+ uint16_t vlan;
+};
+
+struct dst_set {
+ struct dst builtin[32];
+ struct dst *dsts;
+ size_t n, allocated;
+};
+
+static void dst_set_init(struct dst_set *);
+static void dst_set_add(struct dst_set *, const struct dst *);
+static void dst_set_free(struct dst_set *);
+
+static struct ofport *ofbundle_get_a_port(const struct ofbundle *);
+
+static bool
+set_dst(struct action_xlate_ctx *ctx, struct dst *dst,
+ const struct ofbundle *in_bundle, const struct ofbundle *out_bundle)
+{
+ dst->vlan = (out_bundle->vlan >= 0 ? OFP_VLAN_NONE
+ : in_bundle->vlan >= 0 ? in_bundle->vlan
+ : ctx->flow.vlan_tci == 0 ? OFP_VLAN_NONE
+ : vlan_tci_to_vid(ctx->flow.vlan_tci));
+
+ dst->port = (!out_bundle->bond
+ ? ofbundle_get_a_port(out_bundle)
+ : bond_choose_output_slave(out_bundle->bond, &ctx->flow,
+ dst->vlan, &ctx->tags));
+
+ return dst->port != NULL;
+}
+
+static int
+mirror_mask_ffs(mirror_mask_t mask)
+{
+ BUILD_ASSERT_DECL(sizeof(unsigned int) >= sizeof(mask));
+ return ffs(mask);
+}
+
+static void
+dst_set_init(struct dst_set *set)
+{
+ set->dsts = set->builtin;
+ set->n = 0;
+ set->allocated = ARRAY_SIZE(set->builtin);
+}
+
+static void
+dst_set_add(struct dst_set *set, const struct dst *dst)
+{
+ if (set->n >= set->allocated) {
+ size_t new_allocated;
+ struct dst *new_dsts;
+
+ new_allocated = set->allocated * 2;
+ new_dsts = xmalloc(new_allocated * sizeof *new_dsts);
+ memcpy(new_dsts, set->dsts, set->n * sizeof *new_dsts);
+
+ dst_set_free(set);
+
+ set->dsts = new_dsts;
+ set->allocated = new_allocated;
+ }
+ set->dsts[set->n++] = *dst;
+}
+
+static void
+dst_set_free(struct dst_set *set)
+{
+ if (set->dsts != set->builtin) {
+ free(set->dsts);
+ }
+}
+
+static bool
+dst_is_duplicate(const struct dst_set *set, const struct dst *test)
+{
+ size_t i;
+ for (i = 0; i < set->n; i++) {
+ if (set->dsts[i].vlan == test->vlan
+ && set->dsts[i].port == test->port) {
+ return true;
+ }
+ }
+ return false;
+}
+
+static bool
+ofbundle_trunks_vlan(const struct ofbundle *bundle, uint16_t vlan)
+{
+ return bundle->vlan < 0 && vlan_bitmap_contains(bundle->trunks, vlan);
+}
+
+static bool
+ofbundle_includes_vlan(const struct ofbundle *bundle, uint16_t vlan)
+{
+ return vlan == bundle->vlan || ofbundle_trunks_vlan(bundle, vlan);
+}
+
+/* Returns an arbitrary interface within 'bundle'. */
+static struct ofport *
+ofbundle_get_a_port(const struct ofbundle *bundle)
+{
+ return CONTAINER_OF(list_front(&bundle->ports),
+ struct ofport, bundle_node);
+}
+
+static void
+compose_dsts(struct action_xlate_ctx *ctx, uint16_t vlan,
+ const struct ofbundle *in_bundle,
+ const struct ofbundle *out_bundle, struct dst_set *set)
+{
+ struct dst dst;
+
+ if (out_bundle == OFBUNDLE_FLOOD) {
+ struct ofbundle *bundle;
+
+ HMAP_FOR_EACH (bundle, hmap_node, &ctx->ofproto->bundles) {
+ if (bundle != in_bundle
+ && ofbundle_includes_vlan(bundle, vlan)
+ && bundle->floodable
+ && !bundle->mirror_out
+ && set_dst(ctx, &dst, in_bundle, bundle)) {
+ dst_set_add(set, &dst);
+ }
+ }
+ ctx->nf_output_iface = NF_OUT_FLOOD;
+ } else if (out_bundle && set_dst(ctx, &dst, in_bundle, out_bundle)) {
+ dst_set_add(set, &dst);
+ ctx->nf_output_iface = dst.port->odp_port;
+ }
+}
+
+static bool
+vlan_is_mirrored(const struct ofmirror *m, int vlan)
+{
+ return vlan_bitmap_contains(m->vlans, vlan);
+}
+
+static void
+compose_mirror_dsts(struct action_xlate_ctx *ctx,
+ uint16_t vlan, const struct ofbundle *in_bundle,
+ struct dst_set *set)
+{
+ struct ofproto *ofproto = ctx->ofproto;
+ mirror_mask_t mirrors;
+ int flow_vlan;
+ size_t i;
+
+ mirrors = in_bundle->src_mirrors;
+ for (i = 0; i < set->n; i++) {
+ mirrors |= set->dsts[i].port->bundle->dst_mirrors;
+ }
+
+ if (!mirrors) {
+ return;
+ }
+
+ flow_vlan = vlan_tci_to_vid(ctx->flow.vlan_tci);
+ if (flow_vlan == 0) {
+ flow_vlan = OFP_VLAN_NONE;
+ }
+
+ while (mirrors) {
+ struct ofmirror *m = ofproto->mirrors[mirror_mask_ffs(mirrors) - 1];
+ if (vlan_is_mirrored(m, vlan)) {
+ struct dst dst;
+
+ if (m->out) {
+ if (set_dst(ctx, &dst, in_bundle, m->out)
+ && !dst_is_duplicate(set, &dst)) {
+ dst_set_add(set, &dst);
+ }
+ } else {
+ struct ofbundle *bundle;
+
+ HMAP_FOR_EACH (bundle, hmap_node, &ofproto->bundles) {
+ if (ofbundle_includes_vlan(bundle, m->out_vlan)
+ && set_dst(ctx, &dst, in_bundle, bundle))
+ {
+ if (bundle->vlan < 0) {
+ dst.vlan = m->out_vlan;
+ }
+ if (dst_is_duplicate(set, &dst)) {
+ continue;
+ }
+
+ /* Use the vlan tag on the original flow instead of
+ * the one passed in the vlan parameter. This ensures
+ * that we compare the vlan from before any implicit
+ * tagging tags place. This is necessary because
+ * dst->vlan is the final vlan, after removing implicit
+ * tags. */
+ if (bundle == in_bundle && dst.vlan == flow_vlan) {
+ /* Don't send out input port on same VLAN. */
+ continue;
+ }
+ dst_set_add(set, &dst);
+ }
+ }
+ }
+ }
+ mirrors &= mirrors - 1;
+ }
+}
+
+static void
+compose_actions(struct action_xlate_ctx *ctx, uint16_t vlan,
+ const struct ofbundle *in_bundle,
+ const struct ofbundle *out_bundle)
+{
+ uint16_t initial_vlan, cur_vlan;
+ const struct dst *dst;
+ struct dst_set set;
+
+ dst_set_init(&set);
+ compose_dsts(ctx, vlan, in_bundle, out_bundle, &set);
+ compose_mirror_dsts(ctx, vlan, in_bundle, &set);
+
+ /* Output all the packets we can without having to change the VLAN. */
+ initial_vlan = vlan_tci_to_vid(ctx->flow.vlan_tci);
+ if (initial_vlan == 0) {
+ initial_vlan = OFP_VLAN_NONE;
+ }
+ for (dst = set.dsts; dst < &set.dsts[set.n]; dst++) {
+ if (dst->vlan != initial_vlan) {
+ continue;
+ }
+ nl_msg_put_u32(ctx->odp_actions,
+ ODP_ACTION_ATTR_OUTPUT, dst->port->odp_port);
+ }
+
+ /* Then output the rest. */
+ cur_vlan = initial_vlan;
+ for (dst = set.dsts; dst < &set.dsts[set.n]; dst++) {
+ if (dst->vlan == initial_vlan) {
+ continue;
+ }
+ if (dst->vlan != cur_vlan) {
+ if (dst->vlan == OFP_VLAN_NONE) {
+ nl_msg_put_flag(ctx->odp_actions, ODP_ACTION_ATTR_STRIP_VLAN);
+ } else {
+ ovs_be16 tci;
+ tci = htons(dst->vlan & VLAN_VID_MASK);
+ tci |= ctx->flow.vlan_tci & htons(VLAN_PCP_MASK);
+ nl_msg_put_be16(ctx->odp_actions,
+ ODP_ACTION_ATTR_SET_DL_TCI, tci);
+ }
+ cur_vlan = dst->vlan;
+ }
+ nl_msg_put_u32(ctx->odp_actions,
+ ODP_ACTION_ATTR_OUTPUT, dst->port->odp_port);
+ }
+
+ dst_set_free(&set);
+}
+
+/* Returns the effective vlan of a packet, taking into account both the
+ * 802.1Q header and implicitly tagged ports. A value of 0 indicates that
+ * the packet is untagged and -1 indicates it has an invalid header and
+ * should be dropped. */
+static int
+flow_get_vlan(struct ofproto *ofproto, const struct flow *flow,
+ struct ofbundle *in_bundle, bool have_packet)
+{
+ int vlan = vlan_tci_to_vid(flow->vlan_tci);
+ if (in_bundle->vlan >= 0) {
+ if (vlan) {
+ if (have_packet) {
+ static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
+ VLOG_WARN_RL(&rl, "bridge %s: dropping VLAN %d tagged "
+ "packet received on port %s configured with "
+ "implicit VLAN %"PRIu16,
+ ofproto->name, vlan,
+ in_bundle->name, in_bundle->vlan);
+ }
+ return -1;
+ }
+ vlan = in_bundle->vlan;
+ } else {
+ if (!ofbundle_includes_vlan(in_bundle, vlan)) {
+ if (have_packet) {
+ static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
+ VLOG_WARN_RL(&rl, "bridge %s: dropping VLAN %d tagged "
+ "packet received on port %s not configured for "
+ "trunking VLAN %d",
+ ofproto->name, vlan, in_bundle->name, vlan);
+ }
+ return -1;
+ }
+ }
+
+ return vlan;
+}
+
+/* A VM broadcasts a gratuitous ARP to indicate that it has resumed after
+ * migration. Older Citrix-patched Linux DomU used gratuitous ARP replies to
+ * indicate this; newer upstream kernels use gratuitous ARP requests. */
+static bool
+is_gratuitous_arp(const struct flow *flow)
+{
+ return (flow->dl_type == htons(ETH_TYPE_ARP)
+ && eth_addr_is_broadcast(flow->dl_dst)
+ && (flow->nw_proto == ARP_OP_REPLY
+ || (flow->nw_proto == ARP_OP_REQUEST
+ && flow->nw_src == flow->nw_dst)));
+}
+
+static void
+update_learning_table(struct ofproto *ofproto,
+ const struct flow *flow, int vlan,
+ struct ofbundle *in_bundle)
+{
+ struct mac_entry *mac;
+
+ if (!mac_learning_may_learn(ofproto->ml, flow->dl_src, vlan)) {
+ return;
+ }
+
+ mac = mac_learning_insert(ofproto->ml, flow->dl_src, vlan);
+ if (is_gratuitous_arp(flow)) {
+ /* We don't want to learn from gratuitous ARP packets that are
+ * reflected back over bond slaves so we lock the learning table. */
+ if (!in_bundle->bond) {
+ mac_entry_set_grat_arp_lock(mac);
+ } else if (mac_entry_is_grat_arp_locked(mac)) {
+ return;
+ }
+ }
+
+ if (mac_entry_is_new(mac) || mac->port.p != in_bundle) {
+ /* The log messages here could actually be useful in debugging,
+ * so keep the rate limit relatively high. */
+ static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(30, 300);
+ VLOG_DBG_RL(&rl, "bridge %s: learned that "ETH_ADDR_FMT" is "
+ "on port %s in VLAN %d",
+ ofproto->name, ETH_ADDR_ARGS(flow->dl_src),
+ in_bundle->name, vlan);
+
+ mac->port.p = in_bundle;
+ tag_set_add(&ofproto->revalidate_set,
+ mac_learning_changed(ofproto->ml, mac));
+ }
+}
+
+/* Determines whether packets in 'flow' within 'br' should be forwarded or
+ * dropped. Returns true if they may be forwarded, false if they should be
+ * dropped.
+ *
+ * If 'have_packet' is true, it indicates that the caller is processing a
+ * received packet. If 'have_packet' is false, then the caller is just
+ * revalidating an existing flow because configuration has changed. Either
+ * way, 'have_packet' only affects logging (there is no point in logging errors
+ * during revalidation).
+ *
+ * Sets '*in_portp' to the input port. This will be a null pointer if
+ * flow->in_port does not designate a known input port (in which case
+ * is_admissible() returns false).
+ *
+ * When returning true, sets '*vlanp' to the effective VLAN of the input
+ * packet, as returned by flow_get_vlan().
+ *
+ * May also add tags to '*tags', although the current implementation only does
+ * so in one special case.
+ */
+static bool
+is_admissible(struct ofproto *ofproto, const struct flow *flow,
+ bool have_packet,
+ tag_type *tags, int *vlanp, struct ofbundle **in_bundlep)
+{
+ struct ofport *in_port;
+ struct ofbundle *in_bundle;
+ int vlan;
+
+ /* Find the port and bundle for the received packet. */
+ in_port = get_port(ofproto, flow->in_port);
+ *in_bundlep = in_bundle = in_port->bundle;
+ if (!in_port || !in_bundle) {
+ /* No interface? Something fishy... */
+ if (have_packet) {
+ /* Odd. A few possible reasons here:
+ *
+ * - We deleted a port but there are still a few packets queued up
+ * from it.
+ *
+ * - Someone externally added a port (e.g. "ovs-dpctl add-if") that
+ * we don't know about.
+ *
+ * - Packet arrived on the local port but the local port is not
+ * part of a bundle.
+ */
+ static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
+
+ VLOG_WARN_RL(&rl, "bridge %s: received packet on unknown "
+ "port %"PRIu16,
+ ofproto->name, flow->in_port);
+ }
+ return false;
+ }
+ *vlanp = vlan = flow_get_vlan(ofproto, flow, in_bundle, have_packet);
+ if (vlan < 0) {
+ return false;
+ }
+
+ /* Drop frames for reserved multicast addresses. */
+ if (eth_addr_is_reserved(flow->dl_dst)) {
+ return false;
+ }
+
+ /* Drop frames on bundles reserved for mirroring. */
+ if (in_bundle->mirror_out) {
+ if (have_packet) {
+ static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
+ VLOG_WARN_RL(&rl, "bridge %s: dropping packet received on port "
+ "%s, which is reserved exclusively for mirroring",
+ ofproto->name, in_bundle->name);
+ }
+ return false;
+ }
+
+ if (in_bundle->bond) {
+ struct mac_entry *mac;
+
+ switch (bond_check_admissibility(in_bundle->bond, in_port,
+ flow->dl_dst, tags)) {
+ case BV_ACCEPT:
+ break;
+
+ case BV_DROP:
+ return false;
+
+ case BV_DROP_IF_MOVED:
+ mac = mac_learning_lookup(ofproto->ml, flow->dl_src, vlan, NULL);
+ if (mac && mac->port.p != in_bundle &&
+ (!is_gratuitous_arp(flow)
+ || mac_entry_is_grat_arp_locked(mac))) {
+ return false;
+ }
+ break;
+ }
+ }
+
+ return true;
+}
+
+/* If the composed actions may be applied to any packet in the given 'flow',
+ * returns true. Otherwise, the actions should only be applied to 'packet', or
+ * not at all, if 'packet' was NULL. */
+static bool
+xlate_normal(struct action_xlate_ctx *ctx)
+{
+ struct ofbundle *in_bundle;
+ struct ofbundle *out_bundle;
+ struct mac_entry *mac;
+ int vlan;
+
+ /* Check whether we should drop packets in this flow. */
+ if (!is_admissible(ctx->ofproto, &ctx->flow, ctx->packet != NULL,
+ &ctx->tags, &vlan, &in_bundle)) {
+ out_bundle = NULL;
+ goto done;
+ }
+
+ /* Learn source MAC (but don't try to learn from revalidation). */
+ if (ctx->packet) {
+ update_learning_table(ctx->ofproto, &ctx->flow, vlan, in_bundle);
+ }
+
+ /* Determine output bundle. */
+ mac = mac_learning_lookup(ctx->ofproto->ml, ctx->flow.dl_dst, vlan,
+ &ctx->tags);
+ if (mac) {
+ out_bundle = mac->port.p;
+ } else if (!ctx->packet && !eth_addr_is_multicast(ctx->flow.dl_dst)) {
+ /* If we are revalidating but don't have a learning entry then eject
+ * the flow. Installing a flow that floods packets opens up a window
+ * of time where we could learn from a packet reflected on a bond and
+ * blackhole packets before the learning table is updated to reflect
+ * the correct port. */
+ return false;
+ } else {
+ out_bundle = OFBUNDLE_FLOOD;
+ }
+
+ /* Don't send packets out their input bundles. */
+ if (in_bundle == out_bundle) {
+ out_bundle = NULL;
+ }
+
+done:
+ if (in_bundle) {
+ compose_actions(ctx, vlan, in_bundle, out_bundle);
+ }
+
+ return true;
+}
+\f
static void
send_error_oh(const struct ofconn *ofconn, const struct ofp_header *oh,
int error)
(1u << OFPAT_ENQUEUE));
HMAP_FOR_EACH (port, hmap_node, &ofproto->ports) {
- hton_ofp_phy_port(ofpbuf_put(buf, &port->opp, sizeof port->opp));
+ ofpbuf_put(buf, &port->opp, sizeof port->opp);
}
ofconn_send_reply(ofconn, buf);
const struct ofport *ofport = get_port(ctx->ofproto, port);
if (ofport) {
- if (ofport->opp.config & OFPPC_NO_FWD) {
+ if (ofport->opp.config & htonl(OFPPC_NO_FWD)) {
/* Forwarding disabled on port. */
return;
}
}
static void
-flood_packets(struct ofproto *ofproto, uint16_t odp_in_port, uint32_t mask,
+flood_packets(struct ofproto *ofproto, uint16_t odp_in_port, ovs_be32 mask,
uint16_t *nf_output_iface, struct ofpbuf *odp_actions)
{
struct ofport *ofport;
xlate_table_action(ctx, ctx->flow.in_port);
break;
case OFPP_NORMAL:
- if (!ctx->ofproto->ofhooks->normal_cb(&ctx->flow, ctx->packet,
- ctx->odp_actions, &ctx->tags,
- &ctx->nf_output_iface,
- ctx->ofproto->aux)) {
- COVERAGE_INC(ofproto_uninstallable);
- ctx->may_set_up_flow = false;
- }
+ xlate_normal(ctx);
break;
case OFPP_FLOOD:
- flood_packets(ctx->ofproto, ctx->flow.in_port, OFPPC_NO_FLOOD,
+ flood_packets(ctx->ofproto, ctx->flow.in_port, htonl(OFPPC_NO_FLOOD),
&ctx->nf_output_iface, ctx->odp_actions);
break;
case OFPP_ALL:
- flood_packets(ctx->ofproto, ctx->flow.in_port, 0,
+ flood_packets(ctx->ofproto, ctx->flow.in_port, htonl(0),
&ctx->nf_output_iface, ctx->odp_actions);
break;
case OFPP_CONTROLLER:
}
}
+static void
+xlate_autopath(struct action_xlate_ctx *ctx,
+ const struct nx_action_autopath *naa)
+{
+ uint16_t ofp_port = ntohl(naa->id);
+ struct ofport *port;
+
+ port = get_port(ctx->ofproto, ofp_port_to_odp_port(ofp_port));
+ if (!port || !port->bundle) {
+ ofp_port = OFPP_NONE;
+ } else if (port->bundle->bond) {
+ /* Autopath does not support VLAN hashing. */
+ struct ofport *slave = bond_choose_output_slave(
+ port->bundle->bond, &ctx->flow, OFP_VLAN_NONE, &ctx->tags);
+ if (slave) {
+ ofp_port = odp_port_to_ofp_port(slave->odp_port);
+ }
+ }
+ autopath_execute(naa, &ctx->flow, ofp_port);
+}
+
static void
xlate_nicira_action(struct action_xlate_ctx *ctx,
const struct nx_action_header *nah)
const struct nx_action_set_tunnel *nast;
const struct nx_action_set_queue *nasq;
const struct nx_action_multipath *nam;
+ const struct nx_action_autopath *naa;
enum nx_action_subtype subtype = ntohs(nah->subtype);
struct xlate_reg_state state;
ovs_be64 tun_id;
multipath_execute(nam, &ctx->flow);
break;
+ case NXAST_AUTOPATH:
+ naa = (const struct nx_action_autopath *) nah;
+ xlate_autopath(ctx, naa);
+ break;
+
/* If you add a new action here that modifies flow data, don't forget to
* update the flow key in ctx->flow at the same time. */
const struct ofport *port;
port = get_port(ctx->ofproto, ctx->flow.in_port);
- if (port && port->opp.config & (OFPPC_NO_RECV | OFPPC_NO_RECV_STP) &&
+ if (port && port->opp.config & htonl(OFPPC_NO_RECV | OFPPC_NO_RECV_STP) &&
port->opp.config & (eth_addr_equals(ctx->flow.dl_dst, eth_addr_stp)
- ? OFPPC_NO_RECV_STP : OFPPC_NO_RECV)) {
+ ? htonl(OFPPC_NO_RECV_STP)
+ : htonl(OFPPC_NO_RECV))) {
/* Drop this flow. */
return;
}
ctx->check_special = true;
}
-static void
-ofproto_process_cfm(struct ofproto *ofproto, const struct flow *flow,
- const struct ofpbuf *packet)
+static bool
+ofproto_process_special(struct ofproto *ofproto, const struct flow *flow,
+ const struct ofpbuf *packet)
{
- struct ofport *ofport;
-
- ofport = get_port(ofproto, flow->in_port);
- if (ofport && ofport->cfm) {
- cfm_process_heartbeat(ofport->cfm, packet);
+ if (cfm_should_process_flow(flow)) {
+ struct ofport *ofport = get_port(ofproto, flow->in_port);
+ if (ofport && ofport->cfm) {
+ cfm_process_heartbeat(ofport->cfm, packet);
+ }
+ return true;
+ } else if (flow->dl_type == htons(ETH_TYPE_LACP)) {
+ struct ofport *port = get_port(ofproto, flow->in_port);
+ if (port && port->bundle && port->bundle->lacp) {
+ const struct lacp_pdu *pdu = parse_lacp_packet(packet);
+ if (pdu) {
+ lacp_process_pdu(port->bundle->lacp, port, pdu);
+ }
+ return true;
+ }
}
+ return false;
}
static struct ofpbuf *
ctx->recurse = 0;
ctx->last_pop_priority = -1;
- if (ctx->check_special && cfm_should_process_flow(&ctx->flow)) {
- if (ctx->packet) {
- ofproto_process_cfm(ctx->ofproto, &ctx->flow, ctx->packet);
- }
- ctx->may_set_up_flow = false;
- } else if (ctx->check_special
- && ctx->ofproto->ofhooks->special_cb
- && !ctx->ofproto->ofhooks->special_cb(&ctx->flow, ctx->packet,
- ctx->ofproto->aux)) {
+ if (ctx->check_special
+ && ofproto_process_special(ctx->ofproto, &ctx->flow, ctx->packet)) {
ctx->may_set_up_flow = false;
} else {
do_xlate_actions(in, n_in, ctx);
static void
update_port_config(struct ofproto *p, struct ofport *port,
- uint32_t config, uint32_t mask)
+ ovs_be32 config, ovs_be32 mask)
{
mask &= config ^ port->opp.config;
- if (mask & OFPPC_PORT_DOWN) {
- if (config & OFPPC_PORT_DOWN) {
+ if (mask & htonl(OFPPC_PORT_DOWN)) {
+ if (config & htonl(OFPPC_PORT_DOWN)) {
netdev_turn_flags_off(port->netdev, NETDEV_UP, true);
} else {
netdev_turn_flags_on(port->netdev, NETDEV_UP, true);
}
#define REVALIDATE_BITS (OFPPC_NO_RECV | OFPPC_NO_RECV_STP | \
OFPPC_NO_FWD | OFPPC_NO_FLOOD)
- if (mask & REVALIDATE_BITS) {
+ if (mask & htonl(REVALIDATE_BITS)) {
COVERAGE_INC(ofproto_costly_flags);
- port->opp.config ^= mask & REVALIDATE_BITS;
+ port->opp.config ^= mask & htonl(REVALIDATE_BITS);
p->need_revalidate = true;
}
#undef REVALIDATE_BITS
- if (mask & OFPPC_NO_PACKET_IN) {
- port->opp.config ^= OFPPC_NO_PACKET_IN;
+ if (mask & htonl(OFPPC_NO_PACKET_IN)) {
+ port->opp.config ^= htonl(OFPPC_NO_PACKET_IN);
}
}
} else if (memcmp(port->opp.hw_addr, opm->hw_addr, OFP_ETH_ALEN)) {
return ofp_mkerr(OFPET_PORT_MOD_FAILED, OFPPMFC_BAD_HW_ADDR);
} else {
- update_port_config(p, port, ntohl(opm->config), ntohl(opm->mask));
+ update_port_config(p, port, opm->config, opm->mask);
if (opm->advertise) {
netdev_set_advertisements(port->netdev, ntohl(opm->advertise));
}
netdev_get_stats(port->netdev, &stats);
ops = append_ofp_stats_reply(sizeof *ops, ofconn, msgp);
- ops->port_no = htons(port->opp.port_no);
+ ops->port_no = port->opp.port_no;
memset(ops->pad, 0, sizeof ops->pad);
put_32aligned_be64(&ops->rx_packets, htonll(stats.rx_packets));
put_32aligned_be64(&ops->tx_packets, htonll(stats.tx_packets));
}
}
+/* Obtains the NetFlow engine type and engine ID for 'ofproto' into
+ * '*engine_type' and '*engine_id', respectively. */
+void
+ofproto_get_netflow_ids(const struct ofproto *ofproto,
+ uint8_t *engine_type, uint8_t *engine_id)
+{
+ dpif_get_netflow_ids(ofproto->dpif, engine_type, engine_id);
+}
+
static void
query_aggregate_stats(struct ofproto *ofproto, struct cls_rule *target,
ovs_be16 out_port, uint8_t table_id,
struct ofp_queue_stats *reply;
reply = append_ofp_stats_reply(sizeof *reply, cbdata->ofconn, &cbdata->msg);
- reply->port_no = htons(cbdata->ofport->opp.port_no);
+ reply->port_no = cbdata->ofport->opp.port_no;
memset(reply->pad, 0, sizeof reply->pad);
reply->queue_id = htonl(queue_id);
put_32aligned_be64(&reply->tx_bytes, htonll(stats->tx_bytes));
/* Set header pointers in 'flow'. */
flow_extract(upcall->packet, flow.tun_id, flow.in_port, &flow);
- if (cfm_should_process_flow(&flow)) {
- ofproto_process_cfm(p, &flow, upcall->packet);
- ofpbuf_delete(upcall->packet);
- return;
- } else if (p->ofhooks->special_cb
- && !p->ofhooks->special_cb(&flow, upcall->packet, p->aux)) {
+ /* Handle 802.1ag and LACP. */
+ if (ofproto_process_special(p, &flow, upcall->packet)) {
ofpbuf_delete(upcall->packet);
return;
}
/* Don't send a packet-in if OFPPC_NO_PACKET_IN asserted. */
struct ofport *port = get_port(p, flow.in_port);
if (port) {
- if (port->opp.config & OFPPC_NO_PACKET_IN) {
+ if (port->opp.config & htonl(OFPPC_NO_PACKET_IN)) {
COVERAGE_INC(ofproto_no_packet_in);
/* XXX install 'drop' flow entry */
ofpbuf_delete(upcall->packet);
rule_expire(ofproto, rule);
}
- /* Let the hook know that we're at a stable point: all outstanding data
- * in existing flows has been accounted to the account_cb. Thus, the
- * hook can now reasonably do operations that depend on having accurate
- * flow volume accounting (currently, that's just bond rebalancing). */
- if (ofproto->ofhooks->account_checkpoint_cb) {
- ofproto->ofhooks->account_checkpoint_cb(ofproto->aux);
+ /* All outstanding data in existing flows has been accounted, so it's a
+ * good time to do bond rebalancing. */
+ if (ofproto->has_bonded_bundles) {
+ struct ofbundle *bundle;
+
+ HMAP_FOR_EACH (bundle, hmap_node, &ofproto->bundles) {
+ if (bundle->bond) {
+ bond_rebalance(bundle->bond, &ofproto->revalidate_set);
+ }
+ }
}
return MIN(dp_max_idle, 1000);
ds_put_format(&s, " %d:%d", i * BUCKET_WIDTH, buckets[i]);
}
}
- VLOG_INFO("%s: %s (msec:count)",
- dpif_name(ofproto->dpif), ds_cstr(&s));
+ VLOG_INFO("%s: %s (msec:count)", ofproto->name, ds_cstr(&s));
ds_destroy(&s);
}
return eth_addr_to_uint64(ea);
}
\f
+static struct ofproto *
+ofproto_lookup(const char *name)
+{
+ struct ofproto *ofproto;
+
+ HMAP_FOR_EACH_WITH_HASH (ofproto, hmap_node, hash_string(name, 0),
+ &all_ofprotos) {
+ if (!strcmp(ofproto->name, name)) {
+ return ofproto;
+ }
+ }
+ return NULL;
+}
+
static void
ofproto_unixctl_list(struct unixctl_conn *conn, const char *arg OVS_UNUSED,
void *aux OVS_UNUSED)
{
- const struct shash_node *node;
+ struct ofproto *ofproto;
struct ds results;
ds_init(&results);
- SHASH_FOR_EACH (node, &all_ofprotos) {
- ds_put_format(&results, "%s\n", node->name);
+ HMAP_FOR_EACH (ofproto, hmap_node, &all_ofprotos) {
+ ds_put_format(&results, "%s\n", ofproto->name);
}
unixctl_command_reply(conn, 200, ds_cstr(&results));
ds_destroy(&results);
goto exit;
}
- ofproto = shash_find_data(&all_ofprotos, dpname);
+ ofproto = ofproto_lookup(dpname);
if (!ofproto) {
unixctl_command_reply(conn, 501, "Unknown ofproto (use ofproto/list "
"for help)");
free(args);
}
+static void
+ofproto_unixctl_fdb_show(struct unixctl_conn *conn,
+ const char *args, void *aux OVS_UNUSED)
+{
+ struct ds ds = DS_EMPTY_INITIALIZER;
+ const struct ofproto *ofproto;
+ const struct mac_entry *e;
+
+ ofproto = ofproto_lookup(args);
+ if (!ofproto) {
+ unixctl_command_reply(conn, 501, "no such bridge");
+ return;
+ }
+
+ ds_put_cstr(&ds, " port VLAN MAC Age\n");
+ LIST_FOR_EACH (e, lru_node, &ofproto->ml->lrus) {
+ struct ofbundle *bundle = e->port.p;
+ ds_put_format(&ds, "%5d %4d "ETH_ADDR_FMT" %3d\n",
+ ofbundle_get_a_port(bundle)->odp_port,
+ e->vlan, ETH_ADDR_ARGS(e->mac), mac_entry_age(e));
+ }
+ unixctl_command_reply(conn, 200, ds_cstr(&ds));
+ ds_destroy(&ds);
+}
+
static void
ofproto_unixctl_init(void)
{
unixctl_command_register("ofproto/list", ofproto_unixctl_list, NULL);
unixctl_command_register("ofproto/trace", ofproto_unixctl_trace, NULL);
+ unixctl_command_register("fdb/show", ofproto_unixctl_fdb_show, NULL);
}
-\f
-static bool
-default_normal_ofhook_cb(const struct flow *flow, const struct ofpbuf *packet,
- struct ofpbuf *odp_actions, tag_type *tags,
- uint16_t *nf_output_iface, void *ofproto_)
-{
- struct ofproto *ofproto = ofproto_;
- struct mac_entry *dst_mac;
-
- /* Drop frames for reserved multicast addresses. */
- if (eth_addr_is_reserved(flow->dl_dst)) {
- return true;
- }
-
- /* Learn source MAC (but don't try to learn from revalidation). */
- if (packet != NULL
- && mac_learning_may_learn(ofproto->ml, flow->dl_src, 0)) {
- struct mac_entry *src_mac;
-
- src_mac = mac_learning_insert(ofproto->ml, flow->dl_src, 0);
- if (mac_entry_is_new(src_mac) || src_mac->port.i != flow->in_port) {
- /* The log messages here could actually be useful in debugging,
- * so keep the rate limit relatively high. */
- static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(30, 300);
- VLOG_DBG_RL(&rl, "learned that "ETH_ADDR_FMT" is on port %"PRIu16,
- ETH_ADDR_ARGS(flow->dl_src), flow->in_port);
-
- ofproto_revalidate(ofproto,
- mac_learning_changed(ofproto->ml, src_mac));
- src_mac->port.i = flow->in_port;
- }
- }
-
- /* Determine output port. */
- dst_mac = mac_learning_lookup(ofproto->ml, flow->dl_dst, 0, tags);
- if (!dst_mac) {
- flood_packets(ofproto, flow->in_port, OFPPC_NO_FLOOD,
- nf_output_iface, odp_actions);
- } else {
- int out_port = dst_mac->port.i;
- if (out_port != flow->in_port) {
- nl_msg_put_u32(odp_actions, ODP_ACTION_ATTR_OUTPUT, out_port);
- *nf_output_iface = out_port;
- } else {
- /* Drop. */
- }
- }
-
- return true;
-}
-
-static const struct ofhooks default_ofhooks = {
- default_normal_ofhook_cb,
- NULL,
- NULL,
- NULL
-};
git://git.onelab.eu / sliver-openvswitch.git / blobdiff