X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fmac-learning.c;h=052ac48440ce478b3da9ca9e73936c028bcb5677;hb=f40869bdf6feca4d3ff7c59a1fb1f7ac101bc967;hp=efd1dd4b8b052dfdfee62598eae7c3baa854eeff;hpb=82062a2047923e5c403fe42646e1c9eacbc73752;p=sliver-openvswitch.git diff --git a/lib/mac-learning.c b/lib/mac-learning.c index efd1dd4b8..052ac4844 100644 --- a/lib/mac-learning.c +++ b/lib/mac-learning.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009, 2010, 2011 Nicira Networks. + * Copyright (c) 2008, 2009, 2010, 2011, 2012 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -17,7 +17,6 @@ #include #include "mac-learning.h" -#include #include #include @@ -28,6 +27,7 @@ #include "poll-loop.h" #include "tag.h" #include "timeval.h" +#include "unaligned.h" #include "util.h" #include "vlan-bitmap.h" #include "vlog.h" @@ -37,19 +37,21 @@ VLOG_DEFINE_THIS_MODULE(mac_learning); COVERAGE_DEFINE(mac_learning_learned); COVERAGE_DEFINE(mac_learning_expired); -/* Returns the number of seconds since 'e' was last learned. */ +/* Returns the number of seconds since 'e' (within 'ml') was last learned. */ int -mac_entry_age(const struct mac_entry *e) +mac_entry_age(const struct mac_learning *ml, const struct mac_entry *e) { time_t remaining = e->expires - time_now(); - return MAC_ENTRY_IDLE_TIME - remaining; + return ml->idle_time - remaining; } static uint32_t mac_table_hash(const struct mac_learning *ml, const uint8_t mac[ETH_ADDR_LEN], uint16_t vlan) { - return hash_bytes(mac, ETH_ADDR_LEN, vlan ^ ml->secret); + unsigned int mac1 = get_unaligned_u32((uint32_t *) mac); + unsigned int mac2 = get_unaligned_u16((uint16_t *) (mac + 4)); + return hash_3words(mac1, mac2 | (vlan << 16), ml->secret); } static struct mac_entry * @@ -98,9 +100,19 @@ get_lru(struct mac_learning *ml, struct mac_entry **e) } } -/* Creates and returns a new MAC learning table. */ +static unsigned int +normalize_idle_time(unsigned int idle_time) +{ + return (idle_time < 15 ? 15 + : idle_time > 3600 ? 3600 + : idle_time); +} + +/* Creates and returns a new MAC learning table with an initial MAC aging + * timeout of 'idle_time' seconds and an initial maximum of MAC_DEFAULT_MAX + * entries. */ struct mac_learning * -mac_learning_create(void) +mac_learning_create(unsigned int idle_time) { struct mac_learning *ml; @@ -109,6 +121,8 @@ mac_learning_create(void) hmap_init(&ml->table); ml->secret = random_uint32(); ml->flood_vlans = NULL; + ml->idle_time = normalize_idle_time(idle_time); + ml->max_entries = MAC_DEFAULT_MAX; return ml; } @@ -146,6 +160,33 @@ mac_learning_set_flood_vlans(struct mac_learning *ml, } } +/* Changes the MAC aging timeout of 'ml' to 'idle_time' seconds. */ +void +mac_learning_set_idle_time(struct mac_learning *ml, unsigned int idle_time) +{ + idle_time = normalize_idle_time(idle_time); + if (idle_time != ml->idle_time) { + struct mac_entry *e; + int delta; + + delta = (int) idle_time - (int) ml->idle_time; + LIST_FOR_EACH (e, lru_node, &ml->lrus) { + e->expires += delta; + } + ml->idle_time = idle_time; + } +} + +/* Sets the maximum number of entries in 'ml' to 'max_entries', adjusting it + * to be within a reasonable range. */ +void +mac_learning_set_max_entries(struct mac_learning *ml, size_t max_entries) +{ + ml->max_entries = (max_entries < 10 ? 10 + : max_entries > 1000 * 1000 ? 1000 * 1000 + : max_entries); +} + static bool is_learning_vlan(const struct mac_learning *ml, uint16_t vlan) { @@ -182,7 +223,7 @@ mac_learning_insert(struct mac_learning *ml, if (!e) { uint32_t hash = mac_table_hash(ml, src_mac, vlan); - if (hmap_count(&ml->table) >= MAC_MAX) { + if (hmap_count(&ml->table) >= ml->max_entries) { get_lru(ml, &e); mac_learning_expire(ml, e); } @@ -199,7 +240,7 @@ mac_learning_insert(struct mac_learning *ml, /* Mark 'e' as recently used. */ list_push_back(&ml->lrus, &e->lru_node); - e->expires = time_now() + MAC_ENTRY_IDLE_TIME; + e->expires = time_now() + ml->idle_time; return e; } @@ -242,7 +283,7 @@ mac_learning_lookup(const struct mac_learning *ml, } else { struct mac_entry *e = mac_entry_lookup(ml, dst, vlan); - assert(e == NULL || e->tag != 0); + 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); @@ -260,14 +301,18 @@ mac_learning_expire(struct mac_learning *ml, struct mac_entry *e) free(e); } -/* Expires all the mac-learning entries in 'ml'. The tags in 'ml' are - * discarded, so the client is responsible for revalidating any flows that - * depend on 'ml', if necessary. */ +/* Expires all the mac-learning entries in 'ml'. If not NULL, the tags in 'ml' + * are added to 'tags'. Otherwise the tags in 'ml' are discarded. The client + * is responsible for revalidating any flows that depend on 'ml', if + * necessary. */ void -mac_learning_flush(struct mac_learning *ml) +mac_learning_flush(struct mac_learning *ml, struct tag_set *tags) { struct mac_entry *e; while (get_lru(ml, &e)){ + if (tags) { + tag_set_add(tags, e->tag); + } mac_learning_expire(ml, e); } hmap_shrink(&ml->table); @@ -277,7 +322,9 @@ void mac_learning_run(struct mac_learning *ml, struct tag_set *set) { struct mac_entry *e; - while (get_lru(ml, &e) && time_now() >= e->expires) { + 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); @@ -289,7 +336,9 @@ mac_learning_run(struct mac_learning *ml, struct tag_set *set) void mac_learning_wait(struct mac_learning *ml) { - if (!list_is_empty(&ml->lrus)) { + if (hmap_count(&ml->table) > ml->max_entries) { + poll_immediate_wake(); + } else if (!list_is_empty(&ml->lrus)) { struct mac_entry *e = mac_entry_from_lru_node(ml->lrus.next); poll_timer_wait_until(e->expires * 1000LL); }