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; }