[FDB orch]: Fdb orchagent to support fast-reboot (sonic-net#206)

madhanmellanox · May 9, 2017 · eed4a2d · eed4a2d
1 parent 132672f
commit eed4a2d
Show file tree

Hide file tree

Showing 4 changed files with 282 additions and 9 deletions.
diff --git a/doc/swss-schema.md b/doc/swss-schema.md
@@ -169,6 +169,24 @@ and reflects the LAG ports into the redis under: `LAG_TABLE:<team0>:port`
     neigh         = 12HEXDIG         ;  mac address of the neighbor 
     family        = "IPv4" / "IPv6"  ; address family
 
+---------------------------------------------
+###FDB_TABLE
+
+    ; Stores FDB entries which were inserted into SAI state manually
+    ; Notes:
+    ; - only unicast FDB entries supported
+    ; - only Vlan interfaces are supported
+    key           = FDB_TABLE:"Vlan"vlanid:mac_address ; mac address will be inserted to FDB for the vlan interface
+    port          = ifName                ; interface where the entry is bound to
+    type          = "static" / "dynamic"  ; type of the entry
+
+    Example:
+    127.0.0.1:6379> hgetall FDB_TABLE:Vlan2:52-54-00-25-06-E9
+    1) "port"
+    2) "Ethernet0"
+    3) "type"
+    4) "static"
+
 ---------------------------------------------
 ###QUEUE_TABLE
 

diff --git a/orchagent/fdborch.cpp b/orchagent/fdborch.cpp
@@ -1,7 +1,9 @@
 #include <assert.h>
 #include <iostream>
+#include <vector>
 
 #include "logger.h"
+#include "tokenize.h"
 #include "fdborch.h"
 
 extern sai_fdb_api_t *sai_fdb_api;
@@ -19,15 +21,21 @@ void FdbOrch::update(sai_fdb_event_t type, const sai_fdb_entry_t* entry, sai_obj
     case SAI_FDB_EVENT_LEARNED:
         if (!m_portsOrch->getPort(portOid, update.port))
         {
-            SWSS_LOG_ERROR("Failed to get port for %lu OID\n", portOid);
+            SWSS_LOG_ERROR("Failed to get port for %lu OID", portOid);
             return;
         }
 
         update.add = true;
+
+        (void)m_entries.insert(update.entry);
+        SWSS_LOG_DEBUG("FdbOrch notification: mac %s was inserted into vlan %d", update.entry.mac.to_string().c_str(), entry->vlan_id);
         break;
     case SAI_FDB_EVENT_AGED:
     case SAI_FDB_EVENT_FLUSHED:
         update.add = false;
+
+        (void)m_entries.erase(update.entry);
+        SWSS_LOG_DEBUG("FdbOrch notification: mac %s was removed from vlan %d", update.entry.mac.to_string().c_str(), entry->vlan_id);
         break;
     }
 
@@ -51,15 +59,247 @@ bool FdbOrch::getPort(const MacAddress& mac, uint16_t vlan, Port& port)
     sai_status_t status = sai_fdb_api->get_fdb_entry_attribute(&entry, 1, &attr);
     if (status != SAI_STATUS_SUCCESS)
     {
-        SWSS_LOG_INFO("Failed to get port for FDB entry OID\n");
+        SWSS_LOG_ERROR("Failed to get port for FDB entry OID");
         return false;
     }
 
     if (!m_portsOrch->getPort(attr.value.oid, port))
     {
-        SWSS_LOG_ERROR("Failed to get port for %lu OID\n", attr.value.oid);
+        SWSS_LOG_ERROR("Failed to get port for %lu OID", attr.value.oid);
+        return false;
+    }
+
+    return true;
+}
+
+void FdbOrch::doTask(Consumer& consumer)
+{
+    SWSS_LOG_ENTER();
+
+    auto it = consumer.m_toSync.begin();
+    while (it != consumer.m_toSync.end())
+    {
+        KeyOpFieldsValuesTuple t = it->second;
+
+        string key = kfvKey(t);
+        string op = kfvOp(t);
+
+        FdbEntry entry;
+        if (!splitKey(key, entry))
+        {
+            it = consumer.m_toSync.erase(it);
+            continue;
+        }
+
+        if (op == SET_COMMAND)
+        {
+            string port;
+            string type;
+            bool port_defined = false;
+            bool type_defined = false;
+
+            for (auto i : kfvFieldsValues(t))
+            {
+                if (fvField(i) == "port")
+                {
+                    port = fvValue(i);
+                    port_defined = true;
+                }
+
+                if (fvField(i) == "type")
+                {
+                    type = fvValue(i);
+                    type_defined = true;
+                }
+            }
+
+            if (!port_defined)
+            {
+                SWSS_LOG_ERROR("FDB entry with key:'%s' must have 'port' attribute", key.c_str());
+                it = consumer.m_toSync.erase(it);
+                continue;
+            }
+
+            if (!type_defined)
+            {
+                SWSS_LOG_ERROR("FDB entry with key:'%s' must have 'type' attribute", key.c_str());
+                it = consumer.m_toSync.erase(it);
+                continue;
+            }
+
+            // check that type either static or dynamic
+            if (type != "static" && type != "dynamic")
+            {
+                SWSS_LOG_ERROR("FDB entry with key: '%s' has type '%s'. But allowed only types: 'static' or 'dynamic'",
+                               key.c_str(), type.c_str());
+                it = consumer.m_toSync.erase(it);
+                continue;
+            }
+
+            if (addFdbEntry(entry, port, type))
+                it = consumer.m_toSync.erase(it);
+            else
+                it++;
+
+            // Remove AppDb entry if FdbEntry type == 'dynamic'
+            if (type == "dynamic")
+                m_table.del(key);
+        }
+        else if (op == DEL_COMMAND)
+        {
+            if (removeFdbEntry(entry))
+                it = consumer.m_toSync.erase(it);
+            else
+                it++;
+
+        }
+        else
+        {
+            SWSS_LOG_ERROR("Unknown operation type %s", op.c_str());
+            it = consumer.m_toSync.erase(it);
+        }
+    }
+}
+
+bool FdbOrch::addFdbEntry(const FdbEntry& entry, const string& port_name, const string& type)
+{
+    SWSS_LOG_ENTER();
+
+    SWSS_LOG_DEBUG("mac=%s, vlan=%d. port_name %s. type %s",
+                   entry.mac.to_string().c_str(), entry.vlan, port_name.c_str(), type.c_str());
+
+    if (m_entries.count(entry) != 0) // we already have such entries
+    {
+        // FIXME: should we check that the entry are moving to another port?
+        // FIXME: should we check that the entry are changing its type?
+        SWSS_LOG_ERROR("FDB entry already exists. mac=%s vlan=%d", entry.mac.to_string().c_str(), entry.vlan);
+        return true;
+    }
+
+    sai_status_t status;
+
+    sai_fdb_entry_t fdb_entry;
+    memcpy(fdb_entry.mac_address, entry.mac.getMac(), sizeof(sai_mac_t));
+    fdb_entry.vlan_id = entry.vlan;
+
+    Port port;
+    if (!m_portsOrch->getPort(port_name, port))
+    {
+        SWSS_LOG_ERROR("Failed to get port id for %s", port_name.c_str());
+        return true;
+    }
+
+    sai_attribute_t attr;
+    vector<sai_attribute_t> attrs;
+
+    attr.id = SAI_FDB_ENTRY_ATTR_TYPE;
+    attr.value.s32 = (type == "dynamic") ? SAI_FDB_ENTRY_DYNAMIC : SAI_FDB_ENTRY_STATIC;
+    attrs.push_back(attr);
+
+    attr.id = SAI_FDB_ENTRY_ATTR_PORT_ID;
+    attr.value.oid = port.m_port_id;
+    attrs.push_back(attr);
+
+    attr.id = SAI_FDB_ENTRY_ATTR_PACKET_ACTION;
+    attr.value.s32 = SAI_PACKET_ACTION_FORWARD;
+    attrs.push_back(attr);
+
+    status = sai_fdb_api->create_fdb_entry(&fdb_entry, attrs.size(), attrs.data());
+    if (status != SAI_STATUS_SUCCESS)
+    {
+        SWSS_LOG_ERROR("Failed to add FDB entry. mac=%s, vlan=%d. port_name %s. type %s",
+                   entry.mac.to_string().c_str(), entry.vlan, port_name.c_str(), type.c_str());
+        return true;
+    }
+
+    (void)m_entries.insert(entry);
+
+    return true;
+}
+
+bool FdbOrch::removeFdbEntry(const FdbEntry& entry)
+{
+    SWSS_LOG_ENTER();
+
+    SWSS_LOG_DEBUG("mac=%s, vlan=%d", entry.mac.to_string().c_str(), entry.vlan);
+
+    if (m_entries.count(entry) == 0)
+    {
+        SWSS_LOG_ERROR("FDB entry isn't found. mac=%s vlan=%d", entry.mac.to_string().c_str(), entry.vlan);
+        return true;
+    }
+
+    sai_status_t status;
+    sai_fdb_entry_t fdb_entry;
+    memcpy(fdb_entry.mac_address, entry.mac.getMac(), sizeof(sai_mac_t));
+    fdb_entry.vlan_id = entry.vlan;
+
+    status = sai_fdb_api->remove_fdb_entry(&fdb_entry);
+    if (status != SAI_STATUS_SUCCESS)
+    {
+        SWSS_LOG_ERROR("Failed to remove FDB entry. mac=%s, vlan=%d",
+                       entry.mac.to_string().c_str(), entry.vlan);
+        return true;
+    }
+
+    (void)m_entries.erase(entry);
+
+    return true;
+}
+
+bool FdbOrch::splitKey(const string& key, FdbEntry& entry)
+{
+    SWSS_LOG_ENTER();
+
+    string mac_address_str;
+    string vlan_str;
+
+    auto fields = tokenize(key, ':');
+
+    if (fields.size() < 2 || fields.size() > 2)
+    {
+        SWSS_LOG_ERROR("Failed to parse key: %s", key.c_str());
+        return false;
+    }
+
+    vlan_str = fields[0];
+    mac_address_str = fields[1];
+
+    if (vlan_str.length() <= 4) // "Vlan"
+    {
+        SWSS_LOG_ERROR("Failed to extract vlan interface name from the key: %s", key.c_str());
+        return false;
+    }
+
+    uint8_t mac_array[6];
+    if (!MacAddress::parseMacString(mac_address_str, mac_array))
+    {
+        SWSS_LOG_ERROR("Failed to parse mac address: %s in key: %s", mac_address_str.c_str(), key.c_str());
+        return false;
+    }
+
+    if (mac_array[0] & 0x01)
+    {
+        SWSS_LOG_ERROR("Mac address %s in key %s should be unicast", mac_address_str.c_str(), key.c_str());
+        return false;
+    }
+
+    entry.mac = MacAddress(mac_array);
+
+    Port port;
+    if (!m_portsOrch->getPort(vlan_str, port))
+    {
+        SWSS_LOG_ERROR("Failed to get port for %s", vlan_str.c_str());
+        return false;
+    }
+
+    if (port.m_type != Port::VLAN)
+    {
+        SWSS_LOG_ERROR("Port %s from key %s must be a vlan port", vlan_str.c_str(), key.c_str());
         return false;
     }
 
+    entry.vlan = port.m_vlan_id;
+
     return true;
 }
diff --git a/orchagent/fdborch.h b/orchagent/fdborch.h
@@ -8,7 +8,12 @@
 struct FdbEntry
 {
     MacAddress mac;
-    uint16_t vlan;
+    sai_vlan_id_t vlan;
+
+    bool operator<(const FdbEntry& other) const
+    {
+        return tie(mac, vlan) < tie(other.mac, other.vlan);
+    }
 };
 
 struct FdbUpdate
@@ -18,11 +23,13 @@ struct FdbUpdate
     bool add;
 };
 
-class FdbOrch: public Subject
+class FdbOrch: public Orch, public Subject
 {
 public:
-    FdbOrch(PortsOrch *port) :
-        m_portsOrch(port)
+    FdbOrch(DBConnector *db, string tableName, PortsOrch *port) :
+        Orch(db, tableName),
+        m_portsOrch(port),
+        m_table(Table(m_db, tableName))
     {
     }
 
@@ -31,6 +38,14 @@ class FdbOrch: public Subject
 
 private:
     PortsOrch *m_portsOrch;
+    set<FdbEntry> m_entries;
+    Table m_table;
+
+    void doTask(Consumer& consumer);
+
+    bool addFdbEntry(const FdbEntry&, const string&, const string&);
+    bool removeFdbEntry(const FdbEntry&);
+    bool splitKey(const string&, FdbEntry&);
 };
 
 #endif /* SWSS_FDBORCH_H */
diff --git a/orchagent/orchdaemon.cpp b/orchagent/orchdaemon.cpp
@@ -41,7 +41,7 @@ bool OrchDaemon::init()
     };
 
     gPortsOrch = new PortsOrch(m_applDb, ports_tables);
-    gFdbOrch = new FdbOrch(gPortsOrch);
+    gFdbOrch = new FdbOrch(m_applDb, APP_FDB_TABLE_NAME, gPortsOrch);
     IntfsOrch *intfs_orch = new IntfsOrch(m_applDb, APP_INTF_TABLE_NAME);
     NeighOrch *neigh_orch = new NeighOrch(m_applDb, APP_NEIGH_TABLE_NAME, intfs_orch);
     RouteOrch *route_orch = new RouteOrch(m_applDb, APP_ROUTE_TABLE_NAME, neigh_orch);
@@ -79,7 +79,7 @@ bool OrchDaemon::init()
     };
     AclOrch *acl_orch = new AclOrch(m_applDb, acl_tables, gPortsOrch, mirror_orch);
 
-    m_orchList = { gPortsOrch, intfs_orch, neigh_orch, route_orch, copp_orch, tunnel_decap_orch, qos_orch, buffer_orch, mirror_orch, acl_orch};
+    m_orchList = { gPortsOrch, intfs_orch, neigh_orch, route_orch, copp_orch, tunnel_decap_orch, qos_orch, buffer_orch, mirror_orch, acl_orch, gFdbOrch};
     m_select = new Select();
 
     return true;