pfe/common/query_vlan.c - vendor/mindspeed/drivers - Git at Google

 /*
  *  Copyright (c) 2009 Mindspeed Technologies, Inc.
  *
  *  This program is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU General Public License
  *  as published by the Free Software Foundation; either version 2
  *  of the License, or (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
 */
 #include "module_vlan.h"
 #include "layer2.h"


 /* This function returns total vlan interfaces configured in FPP */
 static int Vlan_Get_Hash_Entries(int vlan_hash_index)
 {
 	int tot_vlans=0;
 	struct slist_entry *entry;

 	slist_for_each_entry(entry, &vlan_cache[vlan_hash_index])
 		tot_vlans++;

 	return tot_vlans;
 }


 /* This function fills in the snapshot of all Vlan entries of a VLAN cache */

 static int Vlan_Get_Hash_Snapshot(int vlan_hash_index, int vlan_entries, PVlanCommand pVlanSnapshot)
 {
 	int tot_vlans=0;
 	PVlanEntry pVlanEntry;
 	struct slist_entry *entry;

 	slist_for_each(pVlanEntry, entry, &vlan_cache[vlan_hash_index], list)
 	{
 		pVlanSnapshot->vlanID = ntohs(pVlanEntry->VlanId);
 		strcpy((char *)pVlanSnapshot->vlanifname, get_onif_name(pVlanEntry->itf.index));
 		strcpy((char *)pVlanSnapshot->phyifname, get_onif_name(pVlanEntry->itf.phys->index));

 		pVlanSnapshot++;
 		tot_vlans++;

 		if (--vlan_entries <= 0)
 			break;
 	}

 	return tot_vlans;

 }


 int Vlan_Get_Next_Hash_Entry(PVlanCommand pVlanCmd, int reset_action)
 {
     int total_vlan_entries;
 	PVlanCommand pVlan;
 	static PVlanCommand pVlanSnapshot = NULL;
 	static int vlan_hash_index = 0, vlan_snapshot_entries =0, vlan_snapshot_index=0, vlan_snapshot_buf_entries = 0;

 	if(reset_action)
 	{
 		vlan_hash_index = 0;
 		vlan_snapshot_entries =0;
 		vlan_snapshot_index=0;
 		if(pVlanSnapshot)
 		{
 			Heap_Free(pVlanSnapshot);
 			pVlanSnapshot = NULL;
 		}
 		vlan_snapshot_buf_entries = 0;
 	}

     if (vlan_snapshot_index == 0)
     {
     	while( vlan_hash_index < NUM_VLAN_ENTRIES)
 		{
         	total_vlan_entries = Vlan_Get_Hash_Entries(vlan_hash_index);
         	if (total_vlan_entries == 0)
         	{
         		vlan_hash_index++;
         		continue;
         	}

         	if(total_vlan_entries > vlan_snapshot_buf_entries)
         	{
         		if(pVlanSnapshot)
         			Heap_Free(pVlanSnapshot);

         		pVlanSnapshot = Heap_Alloc(total_vlan_entries * sizeof(VlanCommand));

 				if (!pVlanSnapshot)
 				{
 					vlan_hash_index = 0;
 					vlan_snapshot_buf_entries = 0;
 					return ERR_NOT_ENOUGH_MEMORY;
 				}
 				vlan_snapshot_buf_entries = total_vlan_entries;
         	}


 			vlan_snapshot_entries = Vlan_Get_Hash_Snapshot(vlan_hash_index,total_vlan_entries,pVlanSnapshot);
 			break;

 		}
 		if (vlan_hash_index >= NUM_VLAN_ENTRIES)
 		{
 			vlan_hash_index = 0;
 			if(pVlanSnapshot)
 			{
 				Heap_Free(pVlanSnapshot);
 				pVlanSnapshot = NULL;
 			}
 			vlan_snapshot_buf_entries = 0;
 			return ERR_VLAN_ENTRY_NOT_FOUND;
 		}
     }

    	pVlan = &pVlanSnapshot[vlan_snapshot_index++];

    	SFL_memcpy(pVlanCmd, pVlan, sizeof(VlanCommand));
 	if (vlan_snapshot_index == vlan_snapshot_entries)
 	{
 	    vlan_snapshot_index = 0;
 	    vlan_hash_index++;
 	}

 	return NO_ERR;
 }


 #ifdef CFG_STATS

 #if defined(COMCERTO_2000)
 void stat_vlan_reset(PVlanEntry pEntry)
 {
 	U64 temp;
 	class_statistics_get(&pEntry->total_packets_received, &temp, sizeof(pEntry->total_packets_received), TRUE);
 	class_statistics_get(&pEntry->total_packets_transmitted, &temp, sizeof(pEntry->total_packets_transmitted), TRUE);
 	class_statistics_get(&pEntry->total_bytes_received, &temp, sizeof(pEntry->total_bytes_received), TRUE);
 	class_statistics_get(&pEntry->total_bytes_transmitted, &temp, sizeof(pEntry->total_bytes_transmitted), TRUE);
 }

 static void stat_vlan_get(PVlanEntry pEntry, PStatVlanEntryResponse snapshot, U32 do_reset)
 {
 	class_statistics_get(&pEntry->total_packets_received, &snapshot->total_packets_received, sizeof(pEntry->total_packets_received), do_reset);
 	class_statistics_get(&pEntry->total_packets_transmitted, &snapshot->total_packets_transmitted, sizeof(pEntry->total_packets_transmitted), do_reset);
 	class_statistics_get(&pEntry->total_bytes_received, &snapshot->total_bytes_received, sizeof(pEntry->total_bytes_received), do_reset);
 	class_statistics_get(&pEntry->total_bytes_transmitted, &snapshot->total_bytes_transmitted, sizeof(pEntry->total_bytes_transmitted), do_reset);
 }

 #else
 void stat_vlan_reset(PVlanEntry pEntry)
 {
 	pEntry->total_packets_received = 0;
 	pEntry->total_packets_transmitted = 0;
 	pEntry->total_bytes_received = 0;
 	pEntry->total_bytes_transmitted = 0;
 }

 static void stat_vlan_get(PVlanEntry pEntry, PStatVlanEntryResponse snapshot, U32 do_reset)
 {
 	snapshot->total_packets_received = pEntry->total_packets_received;
 	snapshot->total_packets_transmitted = pEntry->total_packets_transmitted;
       	GET_LSB(pEntry->total_bytes_received, snapshot->total_bytes_received[0], U32);
 	GET_MSB(pEntry->total_bytes_received, snapshot->total_bytes_received[1], U32);
       	GET_LSB(pEntry->total_bytes_transmitted, snapshot->total_bytes_transmitted[0], U32);
 	GET_MSB(pEntry->total_bytes_transmitted, snapshot->total_bytes_transmitted[1], U32);
 	if (do_reset)
 		stat_vlan_reset(pEntry);
 }

 #endif /* !defined(COMCERTO_2000) */

 /* This function fills in the snapshot of all Vlan entries of a VLAN cache along with statistics information*/

 static int stat_VLAN_Get_Session_Snapshot(int stat_vlan_hash_index, int stat_vlan_entries, PStatVlanEntryResponse pStatVLANSnapshot)
 {
 	int stat_tot_vlans=0;
 	PVlanEntry pStatVlanEntry;
 	struct slist_entry *entry;

 	slist_for_each(pStatVlanEntry, entry, &vlan_cache[stat_vlan_hash_index], list)
 	{
 		pStatVLANSnapshot->eof = 0;
 		pStatVLANSnapshot->vlanID = ntohs(pStatVlanEntry->VlanId);
 		strcpy((char *)pStatVLANSnapshot->vlanifname, get_onif_name(pStatVlanEntry->itf.index));
 		strcpy((char *)pStatVLANSnapshot->phyifname, get_onif_name(pStatVlanEntry->itf.phys->index));

 		stat_vlan_get(pStatVlanEntry, pStatVLANSnapshot, gStatVlanQueryStatus & STAT_VLAN_QUERY_RESET);

 		pStatVLANSnapshot++;
 		stat_tot_vlans++;

 		if (--stat_vlan_entries <= 0)
 			break;
 	}

 	return stat_tot_vlans;

 }


 int stat_VLAN_Get_Next_SessionEntry(PStatVlanEntryResponse pStatVlanCmd, int reset_action)
 {
     int stat_total_vlan_entries;
 	PStatVlanEntryResponse pStatVlan;
 	static PStatVlanEntryResponse pStatVLANSnapshot = NULL;
 	static int stat_vlan_hash_index = 0, stat_vlan_snapshot_entries =0, stat_vlan_snapshot_index=0, stat_vlan_snapshot_buf_entries = 0;

 	if(reset_action)
 	{
 		stat_vlan_hash_index = 0;
 		stat_vlan_snapshot_entries =0;
 		stat_vlan_snapshot_index=0;
 		if(pStatVLANSnapshot)
 		{
 			Heap_Free(pStatVLANSnapshot);
 			pStatVLANSnapshot = NULL;
 		}
 		stat_vlan_snapshot_buf_entries = 0;
 		return NO_ERR;
 	}

     	if (stat_vlan_snapshot_index == 0)
     	{
     		while(stat_vlan_hash_index < NUM_VLAN_ENTRIES)
 		{
         		stat_total_vlan_entries = Vlan_Get_Hash_Entries(stat_vlan_hash_index);
         		if (stat_total_vlan_entries == 0)
         		{
         			stat_vlan_hash_index++;
         			continue;
         		}

         		if(stat_total_vlan_entries > stat_vlan_snapshot_buf_entries)
         		{
         			if(pStatVLANSnapshot)
         				Heap_Free(pStatVLANSnapshot);

         			pStatVLANSnapshot = Heap_Alloc(stat_total_vlan_entries * sizeof(StatVlanEntryResponse));

 				if (!pStatVLANSnapshot)
 				{
 					stat_vlan_hash_index = 0;
 					stat_vlan_snapshot_buf_entries = 0;
 					return ERR_NOT_ENOUGH_MEMORY;
 				}
 				stat_vlan_snapshot_buf_entries = stat_total_vlan_entries;
         		}


 			stat_vlan_snapshot_entries = stat_VLAN_Get_Session_Snapshot(stat_vlan_hash_index,stat_total_vlan_entries,pStatVLANSnapshot);
 			break;
 		}

 		if (stat_vlan_hash_index >= NUM_VLAN_ENTRIES)
 		{
 			stat_vlan_hash_index = 0;
 			if(pStatVLANSnapshot)
 			{
 				Heap_Free(pStatVLANSnapshot);
 				pStatVLANSnapshot = NULL;
 			}
 			stat_vlan_snapshot_buf_entries = 0;
 			return ERR_VLAN_ENTRY_NOT_FOUND;
 		}
     	}

    	pStatVlan = &pStatVLANSnapshot[stat_vlan_snapshot_index++];

    	SFL_memcpy(pStatVlanCmd, pStatVlan, sizeof(StatVlanEntryResponse));
 	if (stat_vlan_snapshot_index == stat_vlan_snapshot_entries)
 	{
 	    stat_vlan_snapshot_index = 0;
 	    stat_vlan_hash_index++;
 	}

 	return NO_ERR;
 }

 #endif /* CFG_STATS */
	/*
	* Copyright (c) 2009 Mindspeed Technologies, Inc.
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU General Public License
	* as published by the Free Software Foundation; either version 2
	* of the License, or (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	*
	*/
	#include "module_vlan.h"
	#include "layer2.h"



	/* This function returns total vlan interfaces configured in FPP */
	static int Vlan_Get_Hash_Entries(int vlan_hash_index)
	{
	int tot_vlans=0;
	struct slist_entry *entry;

	slist_for_each_entry(entry, &vlan_cache[vlan_hash_index])
	tot_vlans++;

	return tot_vlans;
	}


	/* This function fills in the snapshot of all Vlan entries of a VLAN cache */

	static int Vlan_Get_Hash_Snapshot(int vlan_hash_index, int vlan_entries, PVlanCommand pVlanSnapshot)
	{
	int tot_vlans=0;
	PVlanEntry pVlanEntry;
	struct slist_entry *entry;

	slist_for_each(pVlanEntry, entry, &vlan_cache[vlan_hash_index], list)
	{
	pVlanSnapshot->vlanID = ntohs(pVlanEntry->VlanId);
	strcpy((char *)pVlanSnapshot->vlanifname, get_onif_name(pVlanEntry->itf.index));
	strcpy((char *)pVlanSnapshot->phyifname, get_onif_name(pVlanEntry->itf.phys->index));

	pVlanSnapshot++;
	tot_vlans++;

	if (--vlan_entries <= 0)
	break;
	}

	return tot_vlans;

	}



	int Vlan_Get_Next_Hash_Entry(PVlanCommand pVlanCmd, int reset_action)
	{
	int total_vlan_entries;
	PVlanCommand pVlan;
	static PVlanCommand pVlanSnapshot = NULL;
	static int vlan_hash_index = 0, vlan_snapshot_entries =0, vlan_snapshot_index=0, vlan_snapshot_buf_entries = 0;

	if(reset_action)
	{
	vlan_hash_index = 0;
	vlan_snapshot_entries =0;
	vlan_snapshot_index=0;
	if(pVlanSnapshot)
	{
	Heap_Free(pVlanSnapshot);
	pVlanSnapshot = NULL;
	}
	vlan_snapshot_buf_entries = 0;
	}

	if (vlan_snapshot_index == 0)
	{
	while( vlan_hash_index < NUM_VLAN_ENTRIES)
	{
	total_vlan_entries = Vlan_Get_Hash_Entries(vlan_hash_index);
	if (total_vlan_entries == 0)
	{
	vlan_hash_index++;
	continue;
	}

	if(total_vlan_entries > vlan_snapshot_buf_entries)
	{
	if(pVlanSnapshot)
	Heap_Free(pVlanSnapshot);

	pVlanSnapshot = Heap_Alloc(total_vlan_entries * sizeof(VlanCommand));

	if (!pVlanSnapshot)
	{
	vlan_hash_index = 0;
	vlan_snapshot_buf_entries = 0;
	return ERR_NOT_ENOUGH_MEMORY;
	}
	vlan_snapshot_buf_entries = total_vlan_entries;
	}


	vlan_snapshot_entries = Vlan_Get_Hash_Snapshot(vlan_hash_index,total_vlan_entries,pVlanSnapshot);
	break;

	}
	if (vlan_hash_index >= NUM_VLAN_ENTRIES)
	{
	vlan_hash_index = 0;
	if(pVlanSnapshot)
	{
	Heap_Free(pVlanSnapshot);
	pVlanSnapshot = NULL;
	}
	vlan_snapshot_buf_entries = 0;
	return ERR_VLAN_ENTRY_NOT_FOUND;
	}
	}

	pVlan = &pVlanSnapshot[vlan_snapshot_index++];

	SFL_memcpy(pVlanCmd, pVlan, sizeof(VlanCommand));
	if (vlan_snapshot_index == vlan_snapshot_entries)
	{
	vlan_snapshot_index = 0;
	vlan_hash_index++;
	}

	return NO_ERR;
	}


	#ifdef CFG_STATS

	#if defined(COMCERTO_2000)
	void stat_vlan_reset(PVlanEntry pEntry)
	{
	U64 temp;
	class_statistics_get(&pEntry->total_packets_received, &temp, sizeof(pEntry->total_packets_received), TRUE);
	class_statistics_get(&pEntry->total_packets_transmitted, &temp, sizeof(pEntry->total_packets_transmitted), TRUE);
	class_statistics_get(&pEntry->total_bytes_received, &temp, sizeof(pEntry->total_bytes_received), TRUE);
	class_statistics_get(&pEntry->total_bytes_transmitted, &temp, sizeof(pEntry->total_bytes_transmitted), TRUE);
	}

	static void stat_vlan_get(PVlanEntry pEntry, PStatVlanEntryResponse snapshot, U32 do_reset)
	{
	class_statistics_get(&pEntry->total_packets_received, &snapshot->total_packets_received, sizeof(pEntry->total_packets_received), do_reset);
	class_statistics_get(&pEntry->total_packets_transmitted, &snapshot->total_packets_transmitted, sizeof(pEntry->total_packets_transmitted), do_reset);
	class_statistics_get(&pEntry->total_bytes_received, &snapshot->total_bytes_received, sizeof(pEntry->total_bytes_received), do_reset);
	class_statistics_get(&pEntry->total_bytes_transmitted, &snapshot->total_bytes_transmitted, sizeof(pEntry->total_bytes_transmitted), do_reset);
	}

	#else
	void stat_vlan_reset(PVlanEntry pEntry)
	{
	pEntry->total_packets_received = 0;
	pEntry->total_packets_transmitted = 0;
	pEntry->total_bytes_received = 0;
	pEntry->total_bytes_transmitted = 0;
	}

	static void stat_vlan_get(PVlanEntry pEntry, PStatVlanEntryResponse snapshot, U32 do_reset)
	{
	snapshot->total_packets_received = pEntry->total_packets_received;
	snapshot->total_packets_transmitted = pEntry->total_packets_transmitted;
	GET_LSB(pEntry->total_bytes_received, snapshot->total_bytes_received[0], U32);
	GET_MSB(pEntry->total_bytes_received, snapshot->total_bytes_received[1], U32);
	GET_LSB(pEntry->total_bytes_transmitted, snapshot->total_bytes_transmitted[0], U32);
	GET_MSB(pEntry->total_bytes_transmitted, snapshot->total_bytes_transmitted[1], U32);
	if (do_reset)
	stat_vlan_reset(pEntry);
	}

	#endif /* !defined(COMCERTO_2000) */

	/* This function fills in the snapshot of all Vlan entries of a VLAN cache along with statistics information*/

	static int stat_VLAN_Get_Session_Snapshot(int stat_vlan_hash_index, int stat_vlan_entries, PStatVlanEntryResponse pStatVLANSnapshot)
	{
	int stat_tot_vlans=0;
	PVlanEntry pStatVlanEntry;
	struct slist_entry *entry;

	slist_for_each(pStatVlanEntry, entry, &vlan_cache[stat_vlan_hash_index], list)
	{
	pStatVLANSnapshot->eof = 0;
	pStatVLANSnapshot->vlanID = ntohs(pStatVlanEntry->VlanId);
	strcpy((char *)pStatVLANSnapshot->vlanifname, get_onif_name(pStatVlanEntry->itf.index));
	strcpy((char *)pStatVLANSnapshot->phyifname, get_onif_name(pStatVlanEntry->itf.phys->index));

	stat_vlan_get(pStatVlanEntry, pStatVLANSnapshot, gStatVlanQueryStatus & STAT_VLAN_QUERY_RESET);

	pStatVLANSnapshot++;
	stat_tot_vlans++;

	if (--stat_vlan_entries <= 0)
	break;
	}

	return stat_tot_vlans;

	}



	int stat_VLAN_Get_Next_SessionEntry(PStatVlanEntryResponse pStatVlanCmd, int reset_action)
	{
	int stat_total_vlan_entries;
	PStatVlanEntryResponse pStatVlan;
	static PStatVlanEntryResponse pStatVLANSnapshot = NULL;
	static int stat_vlan_hash_index = 0, stat_vlan_snapshot_entries =0, stat_vlan_snapshot_index=0, stat_vlan_snapshot_buf_entries = 0;

	if(reset_action)
	{
	stat_vlan_hash_index = 0;
	stat_vlan_snapshot_entries =0;
	stat_vlan_snapshot_index=0;
	if(pStatVLANSnapshot)
	{
	Heap_Free(pStatVLANSnapshot);
	pStatVLANSnapshot = NULL;
	}
	stat_vlan_snapshot_buf_entries = 0;
	return NO_ERR;
	}

	if (stat_vlan_snapshot_index == 0)
	{
	while(stat_vlan_hash_index < NUM_VLAN_ENTRIES)
	{
	stat_total_vlan_entries = Vlan_Get_Hash_Entries(stat_vlan_hash_index);
	if (stat_total_vlan_entries == 0)
	{
	stat_vlan_hash_index++;
	continue;
	}

	if(stat_total_vlan_entries > stat_vlan_snapshot_buf_entries)
	{
	if(pStatVLANSnapshot)
	Heap_Free(pStatVLANSnapshot);

	pStatVLANSnapshot = Heap_Alloc(stat_total_vlan_entries * sizeof(StatVlanEntryResponse));

	if (!pStatVLANSnapshot)
	{
	stat_vlan_hash_index = 0;
	stat_vlan_snapshot_buf_entries = 0;
	return ERR_NOT_ENOUGH_MEMORY;
	}
	stat_vlan_snapshot_buf_entries = stat_total_vlan_entries;
	}


	stat_vlan_snapshot_entries = stat_VLAN_Get_Session_Snapshot(stat_vlan_hash_index,stat_total_vlan_entries,pStatVLANSnapshot);
	break;
	}

	if (stat_vlan_hash_index >= NUM_VLAN_ENTRIES)
	{
	stat_vlan_hash_index = 0;
	if(pStatVLANSnapshot)
	{
	Heap_Free(pStatVLANSnapshot);
	pStatVLANSnapshot = NULL;
	}
	stat_vlan_snapshot_buf_entries = 0;
	return ERR_VLAN_ENTRY_NOT_FOUND;
	}
	}

	pStatVlan = &pStatVLANSnapshot[stat_vlan_snapshot_index++];

	SFL_memcpy(pStatVlanCmd, pStatVlan, sizeof(StatVlanEntryResponse));
	if (stat_vlan_snapshot_index == stat_vlan_snapshot_entries)
	{
	stat_vlan_snapshot_index = 0;
	stat_vlan_hash_index++;
	}

	return NO_ERR;
	}

	#endif /* CFG_STATS */