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

 /*
  *  Copyright (c) 2011, 2014 Freescale Semiconductor, 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_tunnel.h"

 /* This function returns total bridge entries configured
    in a given hash index */

 static int Tnl_Get_Hash_Entries(int hash_index)
 {
 	int tot_tunnels = 0;
 	if (hash_index < 0)
 	{
 		int i;
 		PTnlEntry pTnlEntry;
 		for (i = 0; i < TNL_MAX_TUNNEL_DMEM; i++)
 		{
 			pTnlEntry = &gTNLCtx.tunnel_table[i];
 			if (pTnlEntry->state != TNL_STATE_FREE)
 				tot_tunnels++;
 		}
 	}
 	else
 	{
 		PTnlEntry pStatTunnelEntry;
 		struct slist_entry *entry;
 		slist_for_each(pStatTunnelEntry, entry, &gre_tunnel_cache[hash_index], list)
 		{
 			tot_tunnels++;
 		}
 	}
 	return tot_tunnels;
 }


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

 static void fill_snapshot(PTNLCommand_query pTnlSnapshot, PTnlEntry pTnlEntry)
 {
 	memset(pTnlSnapshot , 0, sizeof(TNLCommand_query));
 	pTnlSnapshot->mode = pTnlEntry->mode;
 	pTnlSnapshot->secure = pTnlEntry->secure;
 	SFL_memcpy(pTnlSnapshot->name, get_onif_name(pTnlEntry->itf.index), 16);
 	SFL_memcpy(pTnlSnapshot->local, pTnlEntry->local, IPV6_ADDRESS_LENGTH);
 	SFL_memcpy(pTnlSnapshot->remote, pTnlEntry->remote, IPV6_ADDRESS_LENGTH);
 	pTnlSnapshot->fl=pTnlEntry->fl;
 	pTnlSnapshot->frag_off = pTnlEntry->frag_off;
 	pTnlSnapshot->enabled = pTnlEntry->state;
 	pTnlSnapshot->elim = pTnlEntry->elim;
 	pTnlSnapshot->hlim = pTnlEntry->hlim;
 	pTnlSnapshot->mtu = pTnlEntry->tnl_mtu;
 }

 static int Tnl_Get_Hash_Snapshot(int hash_index, int tnl_entries, PTNLCommand_query pTnlSnapshot)
 {
         int tot_tnls = 0;
         PTnlEntry pTnlEntry;

 	if (hash_index < 0)
 	{
 		int i;
 		for (i = 0; i < TNL_MAX_TUNNEL_DMEM; i++)
 		{
 			pTnlEntry = &gTNLCtx.tunnel_table[i];
 			if (pTnlEntry->state == TNL_STATE_FREE)
 				continue;
 			fill_snapshot(pTnlSnapshot, pTnlEntry);
 			pTnlSnapshot++;
 			tot_tnls++;
 			tnl_entries--;
 			if (tnl_entries == 0)
 				break;
 		}
 	}
 	else
 	{
 		struct slist_entry *entry;
 		slist_for_each(pTnlEntry, entry, &gre_tunnel_cache[hash_index], list)
 		{
 			fill_snapshot(pTnlSnapshot, pTnlEntry);
 			pTnlSnapshot++;
 			tot_tnls++;
 			tnl_entries--;
 			if (tnl_entries == 0)
 				break;
 		}
 	}
         return tot_tnls;
 }

 U16 Tnl_Get_Next_Hash_Entry(PTNLCommand_query pTnlCmd, int reset_action)
 {
 	int total_tnl_entries;
 	PTNLCommand_query pTnl;
 	static PTNLCommand_query pTnlSnapshot = NULL;
 	static int tnl_hash_index = -1, tnl_snapshot_entries = 0, tnl_snapshot_index = 0;

 	if(reset_action)
 	{
 		tnl_hash_index = -1;
 		tnl_snapshot_entries = 0;
 		tnl_snapshot_index = 0;
 		if (pTnlSnapshot)
 		{
 			Heap_Free(pTnlSnapshot);
 			pTnlSnapshot = NULL;
 		}
 	}

 	if (tnl_snapshot_index == 0)
 	{
 		while (tnl_hash_index < NUM_GRE_TUNNEL_ENTRIES)
 		{
 			total_tnl_entries = Tnl_Get_Hash_Entries(tnl_hash_index);
 			if (total_tnl_entries == 0)
 			{
 				tnl_hash_index++;
 				continue;
 			}
 			if (pTnlSnapshot)
 				Heap_Free(pTnlSnapshot);
 			pTnlSnapshot = Heap_Alloc(total_tnl_entries * sizeof(TNLCommand_query));
 			if (!pTnlSnapshot)
 				return ERR_NOT_ENOUGH_MEMORY;
 			tnl_snapshot_entries = Tnl_Get_Hash_Snapshot(tnl_hash_index, total_tnl_entries, pTnlSnapshot);
 			break;
 		}
 		if (tnl_hash_index >= NUM_GRE_TUNNEL_ENTRIES)
 		{
 			tnl_hash_index = -1;
 			if (pTnlSnapshot)
 			{
 				Heap_Free(pTnlSnapshot);
 				pTnlSnapshot = NULL;
 			}
 			return ERR_TNL_ENTRY_NOT_FOUND;
 		}
 	}

 	pTnl = &pTnlSnapshot[tnl_snapshot_index++];
         SFL_memcpy(pTnlCmd, pTnl, sizeof(TNLCommand_query));
 	if (tnl_snapshot_index == tnl_snapshot_entries)
 	{
 		tnl_snapshot_index = 0;
 		tnl_hash_index ++;
 	}

 	return NO_ERR;
 }


 #ifdef CFG_STATS
 static void stat_tunnel_get(PTnlEntry pEntry, PStatTunnelEntryResponse snapshot, U32 do_reset)
 {
 	PHw_TnlEntry_gre hw_tnl_entry = pEntry->hw_tnl_entry;
 	class_statistics_get_ddr(hw_tnl_entry->total_packets_received, &snapshot->total_packets_received,
 						sizeof(snapshot->total_packets_received), do_reset);
 	class_statistics_get_ddr(hw_tnl_entry->total_packets_transmitted, &snapshot->total_packets_transmitted,
 						sizeof(snapshot->total_packets_transmitted), do_reset);
 	class_statistics_get_ddr(hw_tnl_entry->total_bytes_received, &snapshot->total_bytes_received,
 						sizeof(snapshot->total_bytes_received), do_reset);
 	class_statistics_get_ddr(hw_tnl_entry->total_bytes_transmitted, &snapshot->total_bytes_transmitted,
 						sizeof(snapshot->total_bytes_transmitted), do_reset);
 }

 void stat_tunnel_reset(PTnlEntry pEntry)
 {
 	StatTunnelEntryResponse temp_snapshot;
 	stat_tunnel_get(pEntry, &temp_snapshot, TRUE);
 }

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

 static int stat_tunnel_Get_Session_Snapshot(int hash_index, int stat_tunnel_entries, PStatTunnelEntryResponse pStatTunnelSnapshot)
 {
 	int stat_tot_tunnel = 0;
 	PTnlEntry pStatTunnelEntry;
 	struct slist_entry *entry;

 	slist_for_each(pStatTunnelEntry, entry, &gre_tunnel_cache[hash_index], list)
 	{
 		memset(pStatTunnelSnapshot, 0, sizeof(StatTunnelEntryResponse));
 		strcpy((char *)pStatTunnelSnapshot->ifname, get_onif_name(pStatTunnelEntry->itf.index));
 		stat_tunnel_get(pStatTunnelEntry, pStatTunnelSnapshot, gStatTunnelQueryStatus & STAT_TUNNEL_QUERY_RESET);

 		pStatTunnelSnapshot++;
 		stat_tot_tunnel++;

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

 	return stat_tot_tunnel;
 }


 int stat_tunnel_Get_Next_SessionEntry(PStatTunnelEntryResponse pResponse, int reset_action)
 {
 	int stat_total_tunnel_entries;
 	PStatTunnelStatusCmd pCommand = (PStatTunnelStatusCmd)pResponse;
 	PStatTunnelEntryResponse pStatTunnel;
 	static PStatTunnelEntryResponse pStatTunnelSnapshot = NULL;
 	static int stat_tunnel_hash_index = 0, stat_tunnel_snapshot_entries = 0, stat_tunnel_snapshot_index = 0;
 	static char stat_tunnel_name[IF_NAME_SIZE];

 	if(reset_action)
 	{
 		stat_tunnel_hash_index = 0;
 		stat_tunnel_snapshot_entries = 0;
 		stat_tunnel_snapshot_index = 0;
 		if (pStatTunnelSnapshot)
 		{
 			Heap_Free(pStatTunnelSnapshot);
 			pStatTunnelSnapshot = NULL;
 		}
 		memcpy(stat_tunnel_name, pCommand->ifname, IF_NAME_SIZE - 1);
 		return NO_ERR;
 	}

 top:
 	if (stat_tunnel_snapshot_index == 0)
 	{
 		while(stat_tunnel_hash_index < NUM_GRE_TUNNEL_ENTRIES)
 		{
 			stat_total_tunnel_entries = Tnl_Get_Hash_Entries(stat_tunnel_hash_index);
 			if (stat_total_tunnel_entries == 0)
 			{
 				stat_tunnel_hash_index++;
 				continue;
 			}

 			if(pStatTunnelSnapshot)
 				Heap_Free(pStatTunnelSnapshot);
 			pStatTunnelSnapshot = Heap_Alloc(stat_total_tunnel_entries * sizeof(StatTunnelEntryResponse));
 			if (!pStatTunnelSnapshot)
 			{
 				stat_tunnel_hash_index = 0;
 				return ERR_NOT_ENOUGH_MEMORY;
 			}

 			stat_tunnel_snapshot_entries = stat_tunnel_Get_Session_Snapshot(stat_tunnel_hash_index,stat_total_tunnel_entries,pStatTunnelSnapshot);
 			break;
 		}

 		if (stat_tunnel_hash_index >= NUM_GRE_TUNNEL_ENTRIES)
 		{
 			stat_tunnel_hash_index = 0;
 			if(pStatTunnelSnapshot)
 			{
 				Heap_Free(pStatTunnelSnapshot);
 				pStatTunnelSnapshot = NULL;
 			}
 			return ERR_TNL_ENTRY_NOT_FOUND;
 		}
 	}

 	pStatTunnel = &pStatTunnelSnapshot[stat_tunnel_snapshot_index++];

 	SFL_memcpy(pResponse, pStatTunnel, sizeof(StatTunnelEntryResponse));
 	if (stat_tunnel_snapshot_index == stat_tunnel_snapshot_entries)
 	{
 		stat_tunnel_snapshot_index = 0;
 		stat_tunnel_hash_index++;
 	}

 	if (stat_tunnel_name[0])
 	{
 		// If name is specified, and no match, keep looking
 		if (strcmp(stat_tunnel_name, pResponse->ifname) != 0)
 			goto top;
 		// If name matches, force EOF on next call
 		stat_tunnel_hash_index = NUM_GRE_TUNNEL_ENTRIES;
 		stat_tunnel_snapshot_index = 0;
 	}

 	return NO_ERR;
 }

 #endif	// CFG_STATS
	/*
	* Copyright (c) 2011, 2014 Freescale Semiconductor, 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_tunnel.h"

	/* This function returns total bridge entries configured
	in a given hash index */

	static int Tnl_Get_Hash_Entries(int hash_index)
	{
	int tot_tunnels = 0;
	if (hash_index < 0)
	{
	int i;
	PTnlEntry pTnlEntry;
	for (i = 0; i < TNL_MAX_TUNNEL_DMEM; i++)
	{
	pTnlEntry = &gTNLCtx.tunnel_table[i];
	if (pTnlEntry->state != TNL_STATE_FREE)
	tot_tunnels++;
	}
	}
	else
	{
	PTnlEntry pStatTunnelEntry;
	struct slist_entry *entry;
	slist_for_each(pStatTunnelEntry, entry, &gre_tunnel_cache[hash_index], list)
	{
	tot_tunnels++;
	}
	}
	return tot_tunnels;
	}


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

	static void fill_snapshot(PTNLCommand_query pTnlSnapshot, PTnlEntry pTnlEntry)
	{
	memset(pTnlSnapshot , 0, sizeof(TNLCommand_query));
	pTnlSnapshot->mode = pTnlEntry->mode;
	pTnlSnapshot->secure = pTnlEntry->secure;
	SFL_memcpy(pTnlSnapshot->name, get_onif_name(pTnlEntry->itf.index), 16);
	SFL_memcpy(pTnlSnapshot->local, pTnlEntry->local, IPV6_ADDRESS_LENGTH);
	SFL_memcpy(pTnlSnapshot->remote, pTnlEntry->remote, IPV6_ADDRESS_LENGTH);
	pTnlSnapshot->fl=pTnlEntry->fl;
	pTnlSnapshot->frag_off = pTnlEntry->frag_off;
	pTnlSnapshot->enabled = pTnlEntry->state;
	pTnlSnapshot->elim = pTnlEntry->elim;
	pTnlSnapshot->hlim = pTnlEntry->hlim;
	pTnlSnapshot->mtu = pTnlEntry->tnl_mtu;
	}

	static int Tnl_Get_Hash_Snapshot(int hash_index, int tnl_entries, PTNLCommand_query pTnlSnapshot)
	{
	int tot_tnls = 0;
	PTnlEntry pTnlEntry;

	if (hash_index < 0)
	{
	int i;
	for (i = 0; i < TNL_MAX_TUNNEL_DMEM; i++)
	{
	pTnlEntry = &gTNLCtx.tunnel_table[i];
	if (pTnlEntry->state == TNL_STATE_FREE)
	continue;
	fill_snapshot(pTnlSnapshot, pTnlEntry);
	pTnlSnapshot++;
	tot_tnls++;
	tnl_entries--;
	if (tnl_entries == 0)
	break;
	}
	}
	else
	{
	struct slist_entry *entry;
	slist_for_each(pTnlEntry, entry, &gre_tunnel_cache[hash_index], list)
	{
	fill_snapshot(pTnlSnapshot, pTnlEntry);
	pTnlSnapshot++;
	tot_tnls++;
	tnl_entries--;
	if (tnl_entries == 0)
	break;
	}
	}
	return tot_tnls;
	}

	U16 Tnl_Get_Next_Hash_Entry(PTNLCommand_query pTnlCmd, int reset_action)
	{
	int total_tnl_entries;
	PTNLCommand_query pTnl;
	static PTNLCommand_query pTnlSnapshot = NULL;
	static int tnl_hash_index = -1, tnl_snapshot_entries = 0, tnl_snapshot_index = 0;

	if(reset_action)
	{
	tnl_hash_index = -1;
	tnl_snapshot_entries = 0;
	tnl_snapshot_index = 0;
	if (pTnlSnapshot)
	{
	Heap_Free(pTnlSnapshot);
	pTnlSnapshot = NULL;
	}
	}

	if (tnl_snapshot_index == 0)
	{
	while (tnl_hash_index < NUM_GRE_TUNNEL_ENTRIES)
	{
	total_tnl_entries = Tnl_Get_Hash_Entries(tnl_hash_index);
	if (total_tnl_entries == 0)
	{
	tnl_hash_index++;
	continue;
	}
	if (pTnlSnapshot)
	Heap_Free(pTnlSnapshot);
	pTnlSnapshot = Heap_Alloc(total_tnl_entries * sizeof(TNLCommand_query));
	if (!pTnlSnapshot)
	return ERR_NOT_ENOUGH_MEMORY;
	tnl_snapshot_entries = Tnl_Get_Hash_Snapshot(tnl_hash_index, total_tnl_entries, pTnlSnapshot);
	break;
	}
	if (tnl_hash_index >= NUM_GRE_TUNNEL_ENTRIES)
	{
	tnl_hash_index = -1;
	if (pTnlSnapshot)
	{
	Heap_Free(pTnlSnapshot);
	pTnlSnapshot = NULL;
	}
	return ERR_TNL_ENTRY_NOT_FOUND;
	}
	}

	pTnl = &pTnlSnapshot[tnl_snapshot_index++];
	SFL_memcpy(pTnlCmd, pTnl, sizeof(TNLCommand_query));
	if (tnl_snapshot_index == tnl_snapshot_entries)
	{
	tnl_snapshot_index = 0;
	tnl_hash_index ++;
	}

	return NO_ERR;
	}


	#ifdef CFG_STATS
	static void stat_tunnel_get(PTnlEntry pEntry, PStatTunnelEntryResponse snapshot, U32 do_reset)
	{
	PHw_TnlEntry_gre hw_tnl_entry = pEntry->hw_tnl_entry;
	class_statistics_get_ddr(hw_tnl_entry->total_packets_received, &snapshot->total_packets_received,
	sizeof(snapshot->total_packets_received), do_reset);
	class_statistics_get_ddr(hw_tnl_entry->total_packets_transmitted, &snapshot->total_packets_transmitted,
	sizeof(snapshot->total_packets_transmitted), do_reset);
	class_statistics_get_ddr(hw_tnl_entry->total_bytes_received, &snapshot->total_bytes_received,
	sizeof(snapshot->total_bytes_received), do_reset);
	class_statistics_get_ddr(hw_tnl_entry->total_bytes_transmitted, &snapshot->total_bytes_transmitted,
	sizeof(snapshot->total_bytes_transmitted), do_reset);
	}

	void stat_tunnel_reset(PTnlEntry pEntry)
	{
	StatTunnelEntryResponse temp_snapshot;
	stat_tunnel_get(pEntry, &temp_snapshot, TRUE);
	}

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

	static int stat_tunnel_Get_Session_Snapshot(int hash_index, int stat_tunnel_entries, PStatTunnelEntryResponse pStatTunnelSnapshot)
	{
	int stat_tot_tunnel = 0;
	PTnlEntry pStatTunnelEntry;
	struct slist_entry *entry;

	slist_for_each(pStatTunnelEntry, entry, &gre_tunnel_cache[hash_index], list)
	{
	memset(pStatTunnelSnapshot, 0, sizeof(StatTunnelEntryResponse));
	strcpy((char *)pStatTunnelSnapshot->ifname, get_onif_name(pStatTunnelEntry->itf.index));
	stat_tunnel_get(pStatTunnelEntry, pStatTunnelSnapshot, gStatTunnelQueryStatus & STAT_TUNNEL_QUERY_RESET);

	pStatTunnelSnapshot++;
	stat_tot_tunnel++;

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

	return stat_tot_tunnel;
	}


	int stat_tunnel_Get_Next_SessionEntry(PStatTunnelEntryResponse pResponse, int reset_action)
	{
	int stat_total_tunnel_entries;
	PStatTunnelStatusCmd pCommand = (PStatTunnelStatusCmd)pResponse;
	PStatTunnelEntryResponse pStatTunnel;
	static PStatTunnelEntryResponse pStatTunnelSnapshot = NULL;
	static int stat_tunnel_hash_index = 0, stat_tunnel_snapshot_entries = 0, stat_tunnel_snapshot_index = 0;
	static char stat_tunnel_name[IF_NAME_SIZE];

	if(reset_action)
	{
	stat_tunnel_hash_index = 0;
	stat_tunnel_snapshot_entries = 0;
	stat_tunnel_snapshot_index = 0;
	if (pStatTunnelSnapshot)
	{
	Heap_Free(pStatTunnelSnapshot);
	pStatTunnelSnapshot = NULL;
	}
	memcpy(stat_tunnel_name, pCommand->ifname, IF_NAME_SIZE - 1);
	return NO_ERR;
	}

	top:
	if (stat_tunnel_snapshot_index == 0)
	{
	while(stat_tunnel_hash_index < NUM_GRE_TUNNEL_ENTRIES)
	{
	stat_total_tunnel_entries = Tnl_Get_Hash_Entries(stat_tunnel_hash_index);
	if (stat_total_tunnel_entries == 0)
	{
	stat_tunnel_hash_index++;
	continue;
	}

	if(pStatTunnelSnapshot)
	Heap_Free(pStatTunnelSnapshot);
	pStatTunnelSnapshot = Heap_Alloc(stat_total_tunnel_entries * sizeof(StatTunnelEntryResponse));
	if (!pStatTunnelSnapshot)
	{
	stat_tunnel_hash_index = 0;
	return ERR_NOT_ENOUGH_MEMORY;
	}

	stat_tunnel_snapshot_entries = stat_tunnel_Get_Session_Snapshot(stat_tunnel_hash_index,stat_total_tunnel_entries,pStatTunnelSnapshot);
	break;
	}

	if (stat_tunnel_hash_index >= NUM_GRE_TUNNEL_ENTRIES)
	{
	stat_tunnel_hash_index = 0;
	if(pStatTunnelSnapshot)
	{
	Heap_Free(pStatTunnelSnapshot);
	pStatTunnelSnapshot = NULL;
	}
	return ERR_TNL_ENTRY_NOT_FOUND;
	}
	}

	pStatTunnel = &pStatTunnelSnapshot[stat_tunnel_snapshot_index++];

	SFL_memcpy(pResponse, pStatTunnel, sizeof(StatTunnelEntryResponse));
	if (stat_tunnel_snapshot_index == stat_tunnel_snapshot_entries)
	{
	stat_tunnel_snapshot_index = 0;
	stat_tunnel_hash_index++;
	}

	if (stat_tunnel_name[0])
	{
	// If name is specified, and no match, keep looking
	if (strcmp(stat_tunnel_name, pResponse->ifname) != 0)
	goto top;
	// If name matches, force EOF on next call
	stat_tunnel_hash_index = NUM_GRE_TUNNEL_ENTRIES;
	stat_tunnel_snapshot_index = 0;
	}

	return NO_ERR;
	}

	#endif // CFG_STATS