if (sw->ml) {
ovs_rwlock_wrlock(&sw->ml->rwlock);
- mac_learning_run(sw->ml, NULL);
+ mac_learning_run(sw->ml);
ovs_rwlock_unlock(&sw->ml->rwlock);
}
ovs_rwlock_wrlock(&sw->ml->rwlock);
if (mac_learning_may_learn(sw->ml, flow->dl_src, 0)) {
struct mac_entry *mac = mac_learning_insert(sw->ml, flow->dl_src, 0);
- if (mac_entry_is_new(mac)
- || mac->port.ofp_port != flow->in_port.ofp_port) {
+ if (mac->port.ofp_port != flow->in_port.ofp_port) {
VLOG_DBG_RL(&rl, "%016llx: learned that "ETH_ADDR_FMT" is on "
"port %"PRIu16, sw->datapath_id,
ETH_ADDR_ARGS(flow->dl_src), flow->in_port.ofp_port);
mac->port.ofp_port = flow->in_port.ofp_port;
- mac_learning_changed(sw->ml, mac);
+ mac_learning_changed(sw->ml);
}
}
ovs_rwlock_unlock(&sw->ml->rwlock);
struct mac_entry *mac;
ovs_rwlock_rdlock(&sw->ml->rwlock);
- mac = mac_learning_lookup(sw->ml, flow->dl_dst, 0, NULL);
+ mac = mac_learning_lookup(sw->ml, flow->dl_dst, 0);
if (mac) {
out_port = mac->port.ofp_port;
if (out_port == flow->in_port.ofp_port) {
#include "hash.h"
#include "list.h"
#include "poll-loop.h"
-#include "tag.h"
#include "timeval.h"
#include "unaligned.h"
#include "util.h"
return CONTAINER_OF(list, struct mac_entry, lru_node);
}
-/* Returns a tag that represents that 'mac' is on an unknown port in 'vlan'.
- * (When we learn where 'mac' is in 'vlan', this allows flows that were
- * flooded to be revalidated.) */
-static tag_type
-make_unknown_mac_tag(const struct mac_learning *ml,
- const uint8_t mac[ETH_ADDR_LEN], uint16_t vlan)
-{
- return tag_create_deterministic(mac_table_hash(ml, mac, vlan));
-}
-
static struct mac_entry *
mac_entry_lookup(const struct mac_learning *ml,
const uint8_t mac[ETH_ADDR_LEN], uint16_t vlan)
ml->flood_vlans = NULL;
ml->idle_time = normalize_idle_time(idle_time);
ml->max_entries = MAC_DEFAULT_MAX;
- tag_set_init(&ml->tags);
+ ml->need_revalidate = false;
atomic_init(&ml->ref_cnt, 1);
ovs_rwlock_init(&ml->rwlock);
return ml;
hmap_insert(&ml->table, &e->hmap_node, hash);
memcpy(e->mac, src_mac, ETH_ADDR_LEN);
e->vlan = vlan;
- e->tag = 0;
e->grat_arp_lock = TIME_MIN;
+ e->port.p = NULL;
} else {
list_remove(&e->lru_node);
}
* from mac_learning_insert(), if the entry is either new or if its learned
* port has changed. */
void
-mac_learning_changed(struct mac_learning *ml, struct mac_entry *e)
+mac_learning_changed(struct mac_learning *ml)
{
- tag_type tag = e->tag ? e->tag : make_unknown_mac_tag(ml, e->mac, e->vlan);
-
COVERAGE_INC(mac_learning_learned);
-
- e->tag = tag_create_random();
- tag_set_add(&ml->tags, tag);
+ ml->need_revalidate = true;
}
/* Looks up MAC 'dst' for VLAN 'vlan' in 'ml' and returns the associated MAC
* '*tag'. */
struct mac_entry *
mac_learning_lookup(const struct mac_learning *ml,
- const uint8_t dst[ETH_ADDR_LEN], uint16_t vlan,
- tag_type *tag)
+ const uint8_t dst[ETH_ADDR_LEN], uint16_t vlan)
{
if (eth_addr_is_multicast(dst)) {
/* No tag because the treatment of multicast destinations never
} else {
struct mac_entry *e = mac_entry_lookup(ml, dst, vlan);
- ovs_assert(e == NULL || e->tag != 0);
- if (tag) {
- /* Tag either the learned port or the lack thereof. */
- *tag |= e ? e->tag : make_unknown_mac_tag(ml, dst, vlan);
- }
+ ovs_assert(e == NULL || e->port.p != NULL)
return e;
}
}
* is responsible for revalidating any flows that depend on 'ml', if
* necessary. */
void
-mac_learning_flush(struct mac_learning *ml, struct tag_set *tags)
+mac_learning_flush(struct mac_learning *ml)
{
struct mac_entry *e;
while (get_lru(ml, &e)){
- if (tags) {
- tag_set_add(tags, e->tag);
- }
+ ml->need_revalidate = true;
mac_learning_expire(ml, e);
}
hmap_shrink(&ml->table);
}
-void
-mac_learning_run(struct mac_learning *ml, struct tag_set *set)
+/* Does periodic work required by 'ml'. Returns true if something changed that
+ * may require flow revalidation. */
+bool
+mac_learning_run(struct mac_learning *ml)
{
+ bool need_revalidate;
struct mac_entry *e;
- if (set) {
- tag_set_union(set, &ml->tags);
- }
- tag_set_init(&ml->tags);
-
while (get_lru(ml, &e)
&& (hmap_count(&ml->table) > ml->max_entries
|| time_now() >= e->expires)) {
COVERAGE_INC(mac_learning_expired);
- if (set) {
- tag_set_add(set, e->tag);
- }
+ ml->need_revalidate = true;
mac_learning_expire(ml, e);
}
+
+ need_revalidate = ml->need_revalidate;
+ ml->need_revalidate = false;
+ return need_revalidate;
}
void
mac_learning_wait(struct mac_learning *ml)
{
if (hmap_count(&ml->table) > ml->max_entries
- || !tag_set_is_empty(&ml->tags)) {
+ || ml->need_revalidate) {
poll_immediate_wake();
} else if (!list_is_empty(&ml->lrus)) {
struct mac_entry *e = mac_entry_from_lru_node(ml->lrus.next);
#include "ovs-atomic.h"
#include "ovs-thread.h"
#include "packets.h"
-#include "tag.h"
#include "timeval.h"
struct mac_learning;
time_t grat_arp_lock; /* Gratuitous ARP lock expiration time. */
uint8_t mac[ETH_ADDR_LEN]; /* Known MAC address. */
uint16_t vlan; /* VLAN tag. */
- tag_type tag; /* Tag for this learning entry. */
/* The following are marked guarded to prevent users from iterating over or
* accessing a mac_entry without hodling the parent mac_learning rwlock. */
} port OVS_GUARDED;
};
-/* Returns true if mac_learning_insert() just created 'mac' and the caller has
- * not yet properly initialized it. */
-static inline bool mac_entry_is_new(const struct mac_entry *mac)
-{
- return !mac->tag;
-}
-
/* Sets a gratuitous ARP lock on 'mac' that will expire in
* MAC_GRAT_ARP_LOCK_TIME seconds. */
static inline void mac_entry_set_grat_arp_lock(struct mac_entry *mac)
unsigned long *flood_vlans; /* Bitmap of learning disabled VLANs. */
unsigned int idle_time; /* Max age before deleting an entry. */
size_t max_entries; /* Max number of learned MACs. */
- struct tag_set tags; /* Tags which have changed. */
atomic_int ref_cnt;
struct ovs_rwlock rwlock;
+ bool need_revalidate;
};
int mac_entry_age(const struct mac_learning *ml, const struct mac_entry *e)
struct mac_learning *mac_learning_ref(const struct mac_learning *);
void mac_learning_unref(struct mac_learning *);
-void mac_learning_run(struct mac_learning *ml, struct tag_set *)
- OVS_REQ_WRLOCK(ml->rwlock);
+bool mac_learning_run(struct mac_learning *ml) OVS_REQ_WRLOCK(ml->rwlock);
void mac_learning_wait(struct mac_learning *ml)
OVS_REQ_RDLOCK(ml->rwlock);
const uint8_t src[ETH_ADDR_LEN],
uint16_t vlan)
OVS_REQ_WRLOCK(ml->rwlock);
-void mac_learning_changed(struct mac_learning *ml, struct mac_entry *e)
- OVS_REQ_WRLOCK(ml->rwlock);
+void mac_learning_changed(struct mac_learning *ml) OVS_REQ_WRLOCK(ml->rwlock);
/* Lookup. */
struct mac_entry *mac_learning_lookup(const struct mac_learning *ml,
const uint8_t dst[ETH_ADDR_LEN],
- uint16_t vlan, tag_type *)
+ uint16_t vlan)
OVS_REQ_RDLOCK(ml->rwlock);
/* Flushing. */
void mac_learning_expire(struct mac_learning *ml, struct mac_entry *e)
OVS_REQ_WRLOCK(ml->rwlock);
-void mac_learning_flush(struct mac_learning *ml, struct tag_set *)
- OVS_REQ_WRLOCK(ml->rwlock);
+void mac_learning_flush(struct mac_learning *ml) OVS_REQ_WRLOCK(ml->rwlock);
#endif /* mac-learning.h */
}
}
- if (mac_entry_is_new(mac) || mac->port.p != in_xbundle->ofbundle) {
+ if (mac->port.p != in_xbundle->ofbundle) {
/* 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);
in_xbundle->name, vlan);
mac->port.p = in_xbundle->ofbundle;
- mac_learning_changed(xbridge->ml, mac);
+ mac_learning_changed(xbridge->ml);
}
out:
ovs_rwlock_unlock(&xbridge->ml->rwlock);
case BV_DROP_IF_MOVED:
ovs_rwlock_rdlock(&xbridge->ml->rwlock);
- mac = mac_learning_lookup(xbridge->ml, flow->dl_src, vlan, NULL);
+ 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))) {
/* Determine output bundle. */
ovs_rwlock_rdlock(&ctx->xbridge->ml->rwlock);
- mac = mac_learning_lookup(ctx->xbridge->ml, flow->dl_dst, vlan,
- &ctx->xout->tags);
+ mac = mac_learning_lookup(ctx->xbridge->ml, flow->dl_dst, vlan);
if (mac) {
struct xbundle *mac_xbundle = xbundle_lookup(mac->port.p);
if (mac_xbundle && mac_xbundle != in_xbundle) {
REV_STP, /* Spanning tree protocol port status change. */
REV_PORT_TOGGLED, /* Port enabled or disabled by CFM, LACP, ...*/
REV_FLOW_TABLE, /* Flow table changed. */
+ REV_MAC_LEARNING, /* Mac learning changed. */
REV_INCONSISTENCY /* Facet self-check failed. */
};
COVERAGE_DEFINE(rev_reconfigure);
COVERAGE_DEFINE(rev_stp);
COVERAGE_DEFINE(rev_port_toggled);
COVERAGE_DEFINE(rev_flow_table);
+COVERAGE_DEFINE(rev_mac_learning);
COVERAGE_DEFINE(rev_inconsistency);
/* Drop keys are odp flow keys which have drop flows installed in the kernel.
case REV_STP: COVERAGE_INC(rev_stp); break;
case REV_PORT_TOGGLED: COVERAGE_INC(rev_port_toggled); break;
case REV_FLOW_TABLE: COVERAGE_INC(rev_flow_table); break;
+ case REV_MAC_LEARNING: COVERAGE_INC(rev_mac_learning); break;
case REV_INCONSISTENCY: COVERAGE_INC(rev_inconsistency); break;
}
if (mbridge_need_revalidate(ofproto->mbridge)) {
ofproto->backer->need_revalidate = REV_RECONFIGURE;
ovs_rwlock_wrlock(&ofproto->ml->rwlock);
- mac_learning_flush(ofproto->ml, NULL);
+ mac_learning_flush(ofproto->ml);
ovs_rwlock_unlock(&ofproto->ml->rwlock);
}
stp_run(ofproto);
ovs_rwlock_wrlock(&ofproto->ml->rwlock);
- mac_learning_run(ofproto->ml, &ofproto->backer->revalidate_set);
+ if (mac_learning_run(ofproto->ml)) {
+ ofproto->backer->need_revalidate = REV_MAC_LEARNING;
+ }
ovs_rwlock_unlock(&ofproto->ml->rwlock);
/* Check the consistency of a random facet, to aid debugging. */
!= stp_learn_in_state(state)) {
/* xxx Learning action flows should also be flushed. */
ovs_rwlock_wrlock(&ofproto->ml->rwlock);
- mac_learning_flush(ofproto->ml,
- &ofproto->backer->revalidate_set);
+ mac_learning_flush(ofproto->ml);
ovs_rwlock_unlock(&ofproto->ml->rwlock);
}
fwd_change = stp_forward_in_state(ofport->stp_state)
if (stp_check_and_reset_fdb_flush(ofproto->stp)) {
ovs_rwlock_wrlock(&ofproto->ml->rwlock);
- mac_learning_flush(ofproto->ml, &ofproto->backer->revalidate_set);
+ mac_learning_flush(ofproto->ml);
ovs_rwlock_unlock(&ofproto->ml->rwlock);
}
}
struct mac_entry *e;
ovs_rwlock_wrlock(&o->ml->rwlock);
- e = mac_learning_lookup(o->ml, mac->mac, mac->vlan,
- NULL);
+ e = mac_learning_lookup(o->ml, mac->mac, mac->vlan);
if (e) {
mac_learning_expire(o->ml, e);
}
struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
ovs_rwlock_wrlock(&ofproto->ml->rwlock);
if (mac_learning_set_flood_vlans(ofproto->ml, flood_vlans)) {
- mac_learning_flush(ofproto->ml, &ofproto->backer->revalidate_set);
+ mac_learning_flush(ofproto->ml);
}
ovs_rwlock_unlock(&ofproto->ml->rwlock);
return 0;
return;
}
ovs_rwlock_wrlock(&ofproto->ml->rwlock);
- mac_learning_flush(ofproto->ml, &ofproto->backer->revalidate_set);
+ mac_learning_flush(ofproto->ml);
ovs_rwlock_unlock(&ofproto->ml->rwlock);
} else {
HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
ovs_rwlock_wrlock(&ofproto->ml->rwlock);
- mac_learning_flush(ofproto->ml, &ofproto->backer->revalidate_set);
+ mac_learning_flush(ofproto->ml);
ovs_rwlock_unlock(&ofproto->ml->rwlock);
}
}