void flowTablePurge(OFDPA_FLOW_TABLE_ID_t tableId)
{
OFDPA_ERROR_t rc;
ofdpaFlowEntry_t flow;
ofdpaFlowEntryStats_t flowStats;
uint32_t count;
if (ofdpaFlowTableSupported(tableId) == OFDPA_E_NONE)
{
rc = ofdpaFlowEntryInit(tableId, &flow);
if (rc != OFDPA_E_NONE)
{
printf("Bad return code trying to initialize flow. rc = %d.\r\n", rc);
return;
}
count = 0;
if ((ofdpaFlowStatsGet(&flow, &flowStats) == OFDPA_E_NONE) ||
(ofdpaFlowNextGet(&flow, &flow) == OFDPA_E_NONE))
{
do
{
if ((rc = ofdpaFlowDelete(&flow)) != OFDPA_E_NONE)
{
printf("\tError returned from ofdpaFlowDelete: rc = %d, tableId = %d\n",
rc, flow.tableId);
}
/* flow entry is deleted from OF-DPA even if error is returned, so count it */
count++;
} while (ofdpaFlowNextGet(&flow, &flow) == OFDPA_E_NONE);
}
if (count != 0)
{
printf("\tDeleted %d flows from tableId %d\n", count, flow.tableId);
}
else
{
printf("\tNo entries found in tableId %d\n", flow.tableId);
}
}
}
int main(int argc, char *argv[])
{
char client_name[] = "ofdpa purge client";
OFDPA_ERROR_t rc;
uint32_t count;
ofdpaFlowEntry_t flow;
ofdpaFlowEntryStats_t flowStats;
uint32_t tableIdIndex;
OFDPA_FLOW_TABLE_ID_t flowTablePurgeOrderList[] = {OFDPA_FLOW_TABLE_ID_VLAN,
OFDPA_FLOW_TABLE_ID_TERMINATION_MAC,
OFDPA_FLOW_TABLE_ID_UNICAST_ROUTING,
OFDPA_FLOW_TABLE_ID_MULTICAST_ROUTING,
OFDPA_FLOW_TABLE_ID_BRIDGING,
OFDPA_FLOW_TABLE_ID_ACL_POLICY,
OFDPA_FLOW_TABLE_ID_INGRESS_PORT};
#define FLOW_TABLE_PURGE_LIST_NUM_ENTRIES (sizeof(flowTablePurgeOrderList)/sizeof(OFDPA_FLOW_TABLE_ID_t))
ofdpaGroupEntry_t group;
uint32_t tunnelPortId;
uint32_t ecmpNextHopId;
uint32_t nextHopId;
uint32_t tunnelId;
ofdpaPortEvent_t portEventData;
rc = ofdpaClientInitialize(client_name);
if (rc != OFDPA_E_NONE)
{
printf("\nFailure calling ofdpaClientInitialize(). rc = %d", rc);
return rc;
}
printf("Purging flow tables.\n");
for (tableIdIndex = 0; tableIdIndex < FLOW_TABLE_PURGE_LIST_NUM_ENTRIES; tableIdIndex++)
{
ofdpaFlowEntryInit(flowTablePurgeOrderList[tableIdIndex], &flow);
count = 0;
if ((ofdpaFlowStatsGet(&flow, &flowStats) == OFDPA_E_NONE) ||
(ofdpaFlowNextGet(&flow, &flow) == OFDPA_E_NONE))
{
do
{
if ((rc = ofdpaFlowDelete(&flow)) == OFDPA_E_NONE)
{
count++;
}
else
{
printf("\tError returned from odpaFlowDelete: rc = %d, tableId = %d\n",
rc, flow.tableId);
}
} while (ofdpaFlowNextGet(&flow, &flow) == OFDPA_E_NONE);
}
if (count != 0)
{
printf("\tDeleted %d flows from tableId %d\n", count, flow.tableId);
}
else
{
printf("\tNo entries found in tableId %d\n", flow.tableId);
}
}
printf("Purging group table.\n");
memset(&group, 0, sizeof(group));
count = 0;
while (ofdpaGroupNextGet(group.groupId, &group) == OFDPA_E_NONE)
{
if ((rc = ofdpaGroupDelete(group.groupId)) == OFDPA_E_NONE)
{
count++;
}
else
{
printf("\tError returned from ofdpaGroupDelete: rc = %d, groupId = 0x%08x\n",
rc, group.groupId);
}
}
if (count != 0)
{
printf("\tDeleted %d groups.\n", count);
}
else
{
printf("\tNo entries found\n");
}
printf("Purging logical tunnel port to tenant associations.\n");
tunnelPortId = 0;
ofdpaPortTypeSet(&tunnelPortId, OFDPA_PORT_TYPE_LOGICAL_TUNNEL);
while (ofdpaTunnelPortNextGet(tunnelPortId, &tunnelPortId) == OFDPA_E_NONE)
{
count = 0;
tunnelId = 0;
while (ofdpaTunnelPortTenantNextGet(tunnelPortId, tunnelId, &tunnelId) == OFDPA_E_NONE)
{
if ((rc = ofdpaTunnelPortTenantDelete(tunnelPortId, tunnelId)) == OFDPA_E_NONE)
{
count++;
}
else
{
printf("\tError returned from ofdpaTunnelPortTenantDelete: rc = %d, tunnelPortId = 0x%08x, tunnelId = %d\n",
rc, tunnelPortId, tunnelId);
}
}
if (count != 0)
{
printf("\tDeleted %d tunnel logical port to tenant associations for port 0x%08x.\n", count, tunnelPortId);
}
else
{
printf("\tNo entries found for port 0x%08x.\n", tunnelPortId);
}
}
printf("Purging logical tunnel ports.\n");
tunnelPortId = 0;
ofdpaPortTypeSet(&tunnelPortId, OFDPA_PORT_TYPE_LOGICAL_TUNNEL);
count = 0;
while (ofdpaTunnelPortNextGet(tunnelPortId, &tunnelPortId) == OFDPA_E_NONE)
{
if ((rc = ofdpaTunnelPortDelete(tunnelPortId)) == OFDPA_E_NONE)
{
count++;
}
else
{
printf("\tError returned from ofdpaTunnelPortDelete: rc = %d, tunnelPortId = 0x%08x\n",
rc, tunnelPortId);
}
}
if (count != 0)
{
printf("\tDeleted %d tunnel logical ports.\n", count);
}
else
{
printf("\tNo entries found\n");
}
printf("Purging tunnel ECMP next hop groups.\n");
ecmpNextHopId = 0;
count = 0;
while (ofdpaTunnelEcmpNextHopGroupNextGet(ecmpNextHopId, &ecmpNextHopId) == OFDPA_E_NONE)
{
/* remove any member next hops from this group */
nextHopId = 0;
while ((rc = ofdpaTunnelEcmpNextHopGroupMemberNextGet(ecmpNextHopId, nextHopId, &nextHopId)) == OFDPA_E_NONE)
{
if ((rc = ofdpaTunnelEcmpNextHopGroupMemberDelete(ecmpNextHopId, nextHopId)) != OFDPA_E_NONE)
{
printf("\tError returned from ofdpaTunnelEcmpNextHopGroupMemberDelete: rc = %d, ecmpNextHopId = %d, nextHopId = %d\n",
rc, ecmpNextHopId, nextHopId);
}
}
if ((rc = ofdpaTunnelEcmpNextHopGroupDelete(ecmpNextHopId)) == OFDPA_E_NONE)
{
count++;
}
else
{
printf("\tError returned from ofdpaTunnelEcmpNextHopGroupDelete: rc = %d, nextHopId = 0x%08x\n",
rc, nextHopId);
}
}
if (count != 0)
{
printf("\tDeleted %d ECMP next hop groups.\n", count);
}
else
{
printf("\tNo entries found\n");
}
printf("Purging tenants.\n");
tunnelId = 0;
count = 0;
while (ofdpaTunnelTenantNextGet(tunnelId, &tunnelId) == OFDPA_E_NONE)
{
if ((rc = ofdpaTunnelTenantDelete(tunnelId)) == OFDPA_E_NONE)
{
count++;
}
else
{
printf("\tError returned from ofdpaTunnelTenantDelete: rc = %d, tunnelId = %d\n",
rc, tunnelId);
}
}
if (count != 0)
{
printf("\tDeleted %d tenants.\n", count);
}
else
{
printf("\tNo entries found\n");
}
printf("Purging tunnel next hops.\n");
nextHopId = 0;
count = 0;
while (ofdpaTunnelNextHopNextGet(nextHopId, &nextHopId) == OFDPA_E_NONE)
{
if ((rc = ofdpaTunnelNextHopDelete(nextHopId)) == OFDPA_E_NONE)
{
count++;
}
else
{
printf("\tError returned from ofdpaTunnelNextHopDelete: rc = %d, nextHopId = %d\n",
rc, nextHopId);
}
}
if (count != 0)
{
printf("\tDeleted %d next hops.\n", count);
}
else
{
printf("\tNo entries found\n");
}
/* retrieve all port events to allow logical ports to actually be deleted from database */
memset(&portEventData, 0, sizeof(portEventData));
count = 0;
while (ofdpaPortEventNextGet(&portEventData) == OFDPA_E_NONE)
{
if (portEventData.eventMask & OFDPA_EVENT_PORT_DELETE)
{
count++;
}
}
if (count != 0)
{
printf("\tRetrieved %d port delete events.\n", count);
}
return(0);
}
void dumpFlowTable(OFDPA_FLOW_TABLE_ID_t tableId, int entryPrintLimit, int *entriesPrinted)
{
int i;
OFDPA_ERROR_t rc;
char buffer[700];
ofdpaFlowTableInfo_t info;
ofdpaFlowEntry_t flow;
ofdpaFlowEntryStats_t flowStats;
memset(&info, 0, sizeof(info));
rc = ofdpaFlowTableInfoGet(tableId, &info);
if (!showEmptyTables &&
(info.numEntries == 0))
{
return;
}
printf("Table ID %d (%s): ", tableId, ofdpaFlowTableNameGet(tableId));
if (entryPrintLimit == 0)
{
sprintf(buffer, "all entries");
}
else if (entryPrintLimit == 1)
{
sprintf(buffer, "up to 1 entry");
}
else
{
sprintf(buffer, "up to %d entries", entryPrintLimit);
}
printf(" Retrieving %s. ", buffer);
if (rc != OFDPA_E_NONE)
{
printf("Could not retrieve OF-DPA table info with ID %d. (rc = %d)\r\n", tableId, rc);
}
else
{
printf("Max entries = %d, Current entries = %d.\r\n", info.maxEntries, info.numEntries);
}
rc = ofdpaFlowEntryInit(tableId, &flow);
if (rc != OFDPA_E_NONE)
{
printf("Bad return code trying to initialize flow. rc = %d.\r\n", rc);
return;
}
rc = ofdpaFlowStatsGet(&flow, &flowStats);
if (rc != OFDPA_E_NONE)
{
rc = ofdpaFlowNextGet(&flow, &flow);
}
i = 0;
while ((rc == OFDPA_E_NONE) &&
((entryPrintLimit == 0) || (i < entryPrintLimit)))
{
rc = ofdpaFlowEntryDecode(&flow, buffer, sizeof(buffer));
printf("-- %s%s\r\n", buffer, (rc == OFDPA_E_FULL) ? " -- OUTPUT TRUNCATED! --":"");
i++;
rc = ofdpaFlowNextGet(&flow, &flow);
}
/* blank line between tables */
printf("\r\n");
*entriesPrinted = i;
}
/* Arguments as follows:
* argv[1] - how long to block on receive, in seconds. -1 to block forever.
*/
int main(int argc, char *argv[])
{
char client_name[] = "ofdpa event client";
OFDPA_ERROR_t rc;
int32_t wait;
struct timeval timeout;
struct timeval *tv = NULL;
time_t startTime;
time_t currentTime;
int32_t elapsedSeconds;
ofdpaGroupEntry_t l2IfaceGroup;
ofdpaGroupBucketEntry_t bucket;
ofdpaFlowEntry_t flow;
ofdpaFlowEvent_t flowEventData;
ofdpaPortEvent_t portEventData;
int i;
if (argc == 2)
{
wait = atoi(argv[1]);
}
else
{
wait = -1;
}
rc = ofdpaClientInitialize(client_name);
if (rc != OFDPA_E_NONE)
{
return rc;
}
rc = ofdpaClientEventSockBind();
if (rc != OFDPA_E_NONE)
{
return rc;
}
rc = ofdpaClientPktSockBind();
if (rc != OFDPA_E_NONE)
{
return rc;
}
if (wait >= 0)
{
timeout.tv_sec = wait;
timeout.tv_usec = 0;
tv = &timeout;
printf("\nclient_event: using wait time %d seconds for event\n", wait);
}
else
printf("\nclient_event: waiting indefinitely for events\n");
/* first clear out out any existing flows in the Bridging table */
memset(&flow, 0, sizeof(flow));
flow.tableId = OFDPA_FLOW_TABLE_ID_BRIDGING;
/* wait if OFDPA process not ready for RPC */
while (ofdpaFlowNextGet(&flow, &flow) == OFDPA_E_RPC)
{
printf("\nclient_event: waiting for OF-DPA RPC server to respond\n");
usleep(1000000);
}
do
{
(void)ofdpaFlowDelete(&flow);
} while (ofdpaFlowNextGet(&flow, &flow) == OFDPA_E_NONE);
/* build and add some flows with various hard timeout values */
/* bridging entries need an L2 Interface group */
ofdpaGroupTypeSet(&l2IfaceGroup.groupId, OFDPA_GROUP_ENTRY_TYPE_L2_INTERFACE);
ofdpaGroupVlanSet(&l2IfaceGroup.groupId, 10);
ofdpaGroupPortIdSet(&l2IfaceGroup.groupId, 1);
(void)ofdpaGroupDelete(l2IfaceGroup.groupId);
rc = ofdpaGroupAdd(&l2IfaceGroup);
if (rc != OFDPA_E_NONE)
{
printf("\nError creating required L2 Interface Group entry. rc = %d", rc);
return(3);
}
memset(&bucket, 0, sizeof(bucket));
bucket.groupId = l2IfaceGroup.groupId;
bucket.bucketIndex = 1;
bucket.bucketData.l2Interface.outputPort = 1;
rc = ofdpaGroupBucketEntryAdd(&bucket);
if (rc != OFDPA_E_NONE)
{
printf("\nError creating required L2 Interface Group entry bucket. rc = %d", rc);
return(3);
}
memset(&flow, 0, sizeof(flow));
flow.tableId = OFDPA_FLOW_TABLE_ID_BRIDGING;
flow.flowData.bridgingFlowEntry.gotoTableId = OFDPA_FLOW_TABLE_ID_ACL_POLICY;
flow.flowData.bridgingFlowEntry.match_criteria.destMac.addr[5] = 0x01;
flow.flowData.bridgingFlowEntry.match_criteria.destMacMask.addr[0] = 0xff;
flow.flowData.bridgingFlowEntry.match_criteria.destMacMask.addr[1] = 0xff;
flow.flowData.bridgingFlowEntry.match_criteria.destMacMask.addr[2] = 0xff;
flow.flowData.bridgingFlowEntry.match_criteria.destMacMask.addr[3] = 0xff;
flow.flowData.bridgingFlowEntry.match_criteria.destMacMask.addr[4] = 0xff;
flow.flowData.bridgingFlowEntry.match_criteria.destMacMask.addr[5] = 0xff;
flow.flowData.bridgingFlowEntry.match_criteria.vlanId = 100;
flow.flowData.bridgingFlowEntry.match_criteria.vlanIdMask = OFDPA_VID_PRESENT | OFDPA_VID_EXACT_MASK;
flow.flowData.bridgingFlowEntry.groupID = l2IfaceGroup.groupId;
flow.hard_time = 5;
if ((rc = ofdpaFlowAdd(&flow)) != OFDPA_E_NONE)
{
printf("client_event: ofdpaFlowAdd failed for first flow: rc = %d\n", rc);
/* no sense in continuing if we cannot add the first test flow */
return(-1);
}
/* build up a second flow with a later hard time value */
flow.flowData.bridgingFlowEntry.match_criteria.vlanId++;
flow.hard_time = 15;
if (ofdpaFlowAdd(&flow) != OFDPA_E_NONE)
{
printf("client_event: ofdpaFlowAdd failed for second flow: rc = %d\n", rc);
/* forge ahead */
}
/* build up a flow with a idle time value that expires before the second hard time flow */
flow.flowData.bridgingFlowEntry.match_criteria.vlanId++;
flow.hard_time = 0;
flow.idle_time = 10;
if (ofdpaFlowAdd(&flow) != OFDPA_E_NONE)
{
printf("client_event: ofdpaFlowAdd failed: rc = %d\n", rc);
/* forge ahead */
}
/* build up a flow with a idle time value AND a hard time value to see
if we can get both event types valid for the same flow simultaneously
*/
flow.flowData.bridgingFlowEntry.match_criteria.vlanId++;
flow.hard_time = 12;
flow.idle_time = 12;
if (ofdpaFlowAdd(&flow) != OFDPA_E_NONE)
{
printf("client_event: ofdpaFlowAdd failed: rc = %d\n", rc);
/* forge ahead */
}
flow.idle_time = 0;
/* build up a group of flows with the same hard time value to see if we can
generate multiple flow events sharing the same event notification
*/
flow.hard_time = 20;
for (i=0; i<10; i++)
{
flow.flowData.bridgingFlowEntry.match_criteria.vlanId++;
if (ofdpaFlowAdd(&flow) != OFDPA_E_NONE)
{
printf("client_event: ofdpaFlowAdd failed in flow add loop: rc = %d, i = %d\n", rc, i);
/* forge ahead */
}
}
printf("client_event: waiting for event notifications...\n");
time(&startTime);
while ((rc = ofdpaEventReceive(tv)) == OFDPA_E_NONE)
{
time(¤tTime);
elapsedSeconds = currentTime - startTime;
printf("client_event: received event notification (elapsed time: %d seconds)\n",
elapsedSeconds);
memset(&flowEventData, 0, sizeof(flowEventData));
flowEventData.flowMatch.tableId = OFDPA_FLOW_TABLE_ID_BRIDGING;
while (ofdpaFlowEventNextGet(&flowEventData) == OFDPA_E_NONE)
{
printf("client_event: retrieved aged flow: tableId = %d, eventMask = %x\n",
flowEventData.flowMatch.tableId, flowEventData.eventMask);
printf(" flow data: vlanId = %d\n",
flowEventData.flowMatch.flowData.bridgingFlowEntry.match_criteria.vlanId & OFDPA_VID_EXACT_MASK);
if ((rc = ofdpaFlowDelete(&flowEventData.flowMatch)) != OFDPA_E_NONE)
printf("client_event: ofdpaFlowDelete rc = %d\n", rc);
else
printf("client_event: successfully deleted aged flow\n");
}
memset(&portEventData, 0, sizeof(portEventData));
while (ofdpaPortEventNextGet(&portEventData) == OFDPA_E_NONE)
{
printf("client_event: retrieved port event: port no = %d [0x%x], eventMask = 0x%x, state = %d\n",
portEventData.portNum, portEventData.portNum, portEventData.eventMask, portEventData.state);
}
}
printf("client_event: ofdpaEventReceive rc = %d\n", rc);
/* clean up group entry */
(void)ofdpaGroupDelete(l2IfaceGroup.groupId);
return 0;
}
