/** * @brief computes dependencies and triggers port learning tree updates * * @param triggerPorts port map consisting in the ports which triggered the update * * This function browses through all the ports and determines how to waterfall the update * event from the trigger ports to all other ports depending on them. * * Once the list of ports to be updated is determined this function * calls @ref ixEthDBCreateTrees. * * @internal */ IX_ETH_DB_PUBLIC void ixEthDBUpdatePortLearningTrees(IxEthDBPortMap triggerPorts) { IxEthDBPortMap updatePorts; UINT32 portIndex; ixEthDBUpdateLock(); SET_EMPTY_DEPENDENCY_MAP(updatePorts); for (portIndex = 0 ; portIndex < IX_ETH_DB_NUMBER_OF_PORTS ; portIndex++) { PortInfo *port = &ixEthDBPortInfo[portIndex]; BOOL mapsCollide; MAPS_COLLIDE(mapsCollide, triggerPorts, port->dependencyPortMap); if (mapsCollide /* do triggers influence this port? */ && !IS_PORT_INCLUDED(portIndex, updatePorts) /* and it's not already in the update list */ && port->updateMethod.updateEnabled) /* and we're allowed to update it */ { IX_ETH_DB_UPDATE_TRACE("DB: (Update) Adding port %d to update set\n", portIndex); JOIN_PORT_TO_MAP(updatePorts, portIndex); } else { IX_ETH_DB_UPDATE_TRACE("DB: (Update) Didn't add port %d to update set, reasons follow:\n", portIndex); if (!mapsCollide) { IX_ETH_DB_UPDATE_TRACE("\tMaps don't collide on port %d\n", portIndex); } if (IS_PORT_INCLUDED(portIndex, updatePorts)) { IX_ETH_DB_UPDATE_TRACE("\tPort %d is already in the update set\n", portIndex); } if (!port->updateMethod.updateEnabled) { IX_ETH_DB_UPDATE_TRACE("\tPort %d doesn't have updateEnabled set\n", portIndex); } } } IX_ETH_DB_UPDATE_TRACE("DB: (Update) Updating port set\n"); ixEthDBCreateTrees(updatePorts); ixEthDBUpdateUnlock(); }
/** * @brief queries the database for a set of records to be inserted into a given tree * * @param searchTree pointer to a tree where insertions will be performed; can be NULL * @param query set of ports that a database record must match to be inserted into the tree * * The query method browses through the database, extracts all the descriptors matching * the given query parameter and inserts them into the given learning tree. * Note that this is an append procedure, the given tree needs not to be empty. * A "descriptor matching the query" is a descriptor whose port id is in the query map. * If the given tree is empty (NULL) a new tree is created and returned. * * @return the tree root * * @internal */ IX_ETH_DB_PUBLIC MacTreeNode* ixEthDBQuery(MacTreeNode *searchTree, IxEthDBPortMap query, IxEthDBRecordType recordFilter, UINT32 maxEntries) { HashIterator iterator; UINT32 entryCount = 0; /* browse database */ BUSY_RETRY(ixEthDBInitHashIterator(&dbHashtable, &iterator)); while (IS_ITERATOR_VALID(&iterator)) { MacDescriptor *descriptor = (MacDescriptor *) iterator.node->data; IX_ETH_DB_UPDATE_TRACE("DB: (PortUpdate) querying [%s]:%d on port map ... ", mac2string(descriptor->macAddress), descriptor->portID); if ((descriptor->type & recordFilter) != 0 && IS_PORT_INCLUDED(descriptor->portID, query)) { MacDescriptor *descriptorClone = ixEthDBCloneMacDescriptor(descriptor); IX_ETH_DB_UPDATE_TRACE("match\n"); if (descriptorClone != NULL) { /* add descriptor to tree */ searchTree = ixEthDBTreeInsert(searchTree, descriptorClone); entryCount++; } } else { IX_ETH_DB_UPDATE_TRACE("no match\n"); } if (entryCount < maxEntries) { /* advance to the next record */ BUSY_RETRY(ixEthDBIncrementHashIterator(&dbHashtable, &iterator)); } else { /* the NPE won't accept more entries so we can stop now */ ixEthDBReleaseHashIterator(&iterator); IX_ETH_DB_UPDATE_TRACE("DB: (PortUpdate) number of elements reached maximum supported by port\n"); break; } } IX_ETH_DB_UPDATE_TRACE("DB: (PortUpdate) query inserted %d records in the search tree\n", entryCount); return ixEthDBTreeRebalance(searchTree); }
/** * @brief displays a port dependency map * * @param portID ID of the port * @param map port map to display * * @return IX_ETH_DB_SUCCESS if the operation completed * successfully */ IX_ETH_DB_PUBLIC IxEthDBStatus ixEthDBDependencyPortMapShow(IxEthDBPortId portID, IxEthDBPortMap map) { UINT32 portIndex; BOOL mapSelf = TRUE, mapNone = TRUE, firstPort = TRUE; /* dependency port maps */ printf("Dependency port map: "); /* browse the port map */ for (portIndex = 0 ; portIndex < IX_ETH_DB_NUMBER_OF_PORTS ; portIndex++) { if (IS_PORT_INCLUDED(portIndex, map)) { mapNone = FALSE; if (portIndex != portID) { mapSelf = FALSE; } printf("%s%d", firstPort ? "{" : ", ", portIndex); firstPort = FALSE; } } if (mapNone) { mapSelf = FALSE; } printf("%s (%s)\n", firstPort ? "" : "}", mapSelf ? "self" : mapNone ? "none" : "group"); return IX_ETH_DB_SUCCESS; }
/** * @brief creates learning trees and calls the port update handlers * * @param updatePorts set of ports in need of learning trees * * This function determines the optimal method of creating learning * trees using a minimal number of database queries, keeping in mind * that different ports can either use the same learning trees or they * can partially share them. The actual tree building routine is * @ref ixEthDBQuery. * * @internal */ IX_ETH_DB_PRIVATE void ixEthDBCreateTrees(IxEthDBPortMap updatePorts) { UINT32 portIndex; BOOL result; BOOL portsLeft = TRUE; while (portsLeft) { /* get port with minimal dependency map and NULL search tree */ UINT32 minPortIndex = MAX_PORT_SIZE; UINT32 minimalSize = MAX_PORT_SIZE; for (portIndex = 0 ; portIndex < IX_ETH_DB_NUMBER_OF_PORTS ; portIndex++) { UINT32 size; PortInfo *port = &ixEthDBPortInfo[portIndex]; /* generate trees only for ports that need them */ if (!port->updateMethod.searchTreePendingWrite && IS_PORT_INCLUDED(portIndex, updatePorts)) { GET_MAP_SIZE(port->dependencyPortMap, size); IX_ETH_DB_UPDATE_TRACE("DB: (Update) Dependency map for port %d: size %d\n", portIndex, size); if (size < minimalSize) { minPortIndex = portIndex; minimalSize = size; } } else { IX_ETH_DB_UPDATE_TRACE("DB: (Update) Skipped port %d from tree diff (%s)\n", portIndex, port->updateMethod.searchTreePendingWrite ? "pending write access" : "ignored by query"); } } /* if a port was found than minimalSize is not MAX_PORT_SIZE */ if (minimalSize != MAX_PORT_SIZE) { /* minPortIndex is the port we seek */ PortInfo *port = &ixEthDBPortInfo[minPortIndex]; IxEthDBPortMap query; MacTreeNode *baseTree; /* now try to find a port with minimal map difference */ PortInfo *minimalDiffPort = NULL; UINT32 minimalDiff = MAX_PORT_SIZE; IX_ETH_DB_UPDATE_TRACE("DB: (Update) Minimal size port is %d\n", minPortIndex); for (portIndex = 0 ; portIndex < IX_ETH_DB_NUMBER_OF_PORTS ; portIndex++) { PortInfo *diffPort = &ixEthDBPortInfo[portIndex]; BOOL mapIsSubset; IS_MAP_SUBSET(mapIsSubset, diffPort->dependencyPortMap, port->dependencyPortMap); if (portIndex != minPortIndex && diffPort->updateMethod.searchTree != NULL && mapIsSubset) { /* compute size and pick only minimal size difference */ UINT32 diffPortSize; UINT32 sizeDifference; GET_MAP_SIZE(diffPort->dependencyPortMap, diffPortSize); IX_ETH_DB_UPDATE_TRACE("DB: (Update) Checking port %d for differences...\n", portIndex); sizeDifference = minimalSize - diffPortSize; if (sizeDifference < minimalDiff) { minimalDiffPort = diffPort; minimalDiff = sizeDifference; IX_ETH_DB_UPDATE_TRACE("DB: (Update) Minimal difference 0x%x was found on port %d\n", minimalDiff, portIndex); } } } /* check if filtering is enabled on this port */ if ((port->featureStatus & IX_ETH_DB_FILTERING) != 0) { /* if minimalDiff is not MAX_PORT_SIZE minimalDiffPort points to the most similar port */ if (minimalDiff != MAX_PORT_SIZE) { baseTree = ixEthDBCloneMacTreeNode(minimalDiffPort->updateMethod.searchTree); DIFF_MAPS(query, port->dependencyPortMap , minimalDiffPort->dependencyPortMap); IX_ETH_DB_UPDATE_TRACE("DB: (Update) Found minimal diff, extending tree %d on query\n", minimalDiffPort->portID); } else /* .. otherwise no similar port was found, build tree from scratch */ { baseTree = NULL; COPY_DEPENDENCY_MAP(query, port->dependencyPortMap); IX_ETH_DB_UPDATE_TRACE("DB: (Update) No similar diff, creating tree from query\n"); } IS_EMPTY_DEPENDENCY_MAP(result, query); if (!result) /* otherwise we don't need anything more on top of the cloned tree */ { IX_ETH_DB_UPDATE_TRACE("DB: (Update) Adding query tree to port %d\n", minPortIndex); /* build learning tree */ port->updateMethod.searchTree = ixEthDBQuery(baseTree, query, IX_ETH_DB_ALL_FILTERING_RECORDS, MAX_ELT_SIZE - 1); } else { IX_ETH_DB_UPDATE_TRACE("DB: (Update) Query is empty, assuming identical nearest tree\n"); port->updateMethod.searchTree = baseTree; } } else { /* filtering is not enabled, will download an empty tree */ if (port->updateMethod.searchTree != NULL) { ixEthDBFreeMacTreeNode(port->updateMethod.searchTree); } port->updateMethod.searchTree = NULL; } /* mark tree as valid */ port->updateMethod.searchTreePendingWrite = TRUE; } else { portsLeft = FALSE; IX_ETH_DB_UPDATE_TRACE("DB: (Update) No trees to create this round\n"); } } for (portIndex = 0 ; portIndex < IX_ETH_DB_NUMBER_OF_PORTS ; portIndex++) { PortInfo *updatePort = &ixEthDBPortInfo[portIndex]; if (updatePort->updateMethod.searchTreePendingWrite) { IX_ETH_DB_UPDATE_TRACE("DB: (PortUpdate) Starting procedure to upload new search tree (%snull) into NPE %d\n", updatePort->updateMethod.searchTree != NULL ? "not " : "", portIndex); updatePort->updateMethod.updateHandler(portIndex, IX_ETH_DB_FILTERING_RECORD); } } }