/*
*------------------------------------------------------------------
* cnat_va_db.c - virtual assembly database
*
* Copyright (c) 2009, 2013 Cisco and/or its affiliates.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*------------------------------------------------------------------
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <cnat_va_db.h>
#include <format.h>
#include <spp_node.h>
#include <spp_alloc.h>
#include <spp_byteorder.h>
#include <spp_main.h>
#include <spp_cache.h>
#include <spp_interface.h>
#include <spp_api.h>
#include <spp_client_api.h>
#include <spp_timers.h>
#include <cnat_db.h>
#include <spp_plugin.h>
#include <cnat_v4_functions.h>
va_bucket_t va_bucket[VA_BUCKETS];
void va_bucket_init () {
u32 i;
/*
* set the pointer in each bucket
* points to nowhere
*/
for (i=0; i<VA_BUCKETS; i++) {
va_bucket[i].next_available_entry = ~0;
}
}
inline void va_db_add_new_entry (u32 bucket_index,
va_lookup_key * key )
{
va_entry_t * entry_p;
u32 head, next;
entry_p = va_db_lookup(bucket_index, key);
if (PREDICT_FALSE(entry_p)) {
FRAG_DEBUG_PRINTF6(
"\nVA_ADD_NEW: Bucket %d fnd Existng entry [%d, %d] -> [%d, %d]\n",
bucket_index, entry_p->src_port,
entry_p->dst_port, key->e.src_port, key->e.dst_port)
/* found match entry, update it */
entry_p->src_port = key->e.src_port;
entry_p->dst_port = key->e.dst_port;
FRAG_DEBUG_PRINTF3("VA_ADD_NEW: Existing bucket %d, counter %d\n",
bucket_index,
va_bucket[bucket_index].new_entry_counter)
} else {
/* no match, add a new one */
head = va_bucket[bucket_index].head_entry;
next = va_bucket[bucket_index].next_available_entry;
FRAG_DEBUG_PRINTF5(
"\nVA_ADD_NEW: Filling bucket %d, index %d with key 0x%llx %x\n",
bucket_index, next, key->k.key64, key->k.key32)
va_bucket[bucket_index].va_entry[next] = key->e;
/* increase next pointer */
va_bucket[bucket_index].next_available_entry = (next+1) & VA_BUCKET_MASK;
if (PREDICT_FALSE(head == va_bucket[bucket_index].next_available_entry)) {
/* adjust head circular pointer */
va_bucket[bucket_index].head_entry = (head+1) & VA_BUCKET_MASK;
}
va_bucket[bucket_index].new_entry_counter++;
FRAG_DEBUG_PRINTF4(
"VA_ADD_NEW: NEW bucket %d, entry %d counter %d\n",
bucket_index, next, va_bucket[bucket_index].new_entry_counter)
}
}
/*
* use the key,
* return pointer to the entry if found,
* NULL if not
*/
inline
va_entry_t * va_db_lookup (u32 bucket_index, va_lookup_key * key)
{
u32 index, next;
va_entry_t * entry_p;
va_bucket_t * bucket;
bucket = &va_bucket[bucket_index];
index = bucket->head_entry;
next = bucket->next_available_entry;
entry_p = NULL;
FRAG_DEBUG_PRINTF4(
"\nVA_DB_LOOKUP: bucket index %d head %d next %d\n",
bucket_index, index, next)
/* loop through the entries in the bucket */
while( index != next) {
if(PREDICT_TRUE(memcmp(&bucket->va_entry[index], key, VA_KEY_SIZE)==0)) {
entry_p = &bucket->va_entry[index];
/*In add frag entry function we are again assigning key's src
port to entry_p's src port. So when a main DB entry is deleted/
timed out, and again another entry is created for the same
src ip and src port pair, the frag's entry_p will have the
previous port info stored and not updated. Hence the below
line is not required*/
/* *(u32*)&key->e.src_port = *(u32*)&entry_p->src_port; */
/* do two ports as u32 :) */
break;
}
index = (index +1) & VA_BUCKET_MASK;
}
#ifdef FRAG_DEBUG
if (PREDICT_TRUE(entry_p)) {
FRAG_DEBUG_PRINTF3("VA_DB_LOOKUP: bucket index %d entry index %d\n",
bucket_index, index)
FRAG_DEBUG_PRINTF5("VA_DB_LOOKUP: SRC-->DST [0x%x, %d] [0x%x, %d]\n",
entry_p->src_ip, entry_p->src_port,
entry_p->dst_ip, entry_p->dst_port)
FRAG_DEBUG_PRINTF3("[vrf 0x%x, id 0x%x]\n",
entry_p->vrf, entry_p->ip_id)
} else {
FRAG_DEBUG_PRINTF1("\nNULL ENTRY\n")
}
#endif
return entry_p;
}
inline
int va_db_delete_entry (u32 bucket_index, va_lookup_key * key)
{
u32 index, next;
int entry_found = 0;
va_bucket_t * bucket;
bucket = &va_bucket[bucket_index];
index = bucket->head_entry;
next = bucket->next_available_entry;
FRAG_DEBUG_PRINTF4(
"\nVA_DB_DELETE_ENTRY: bucket index %d head %d next %d\n",
bucket_index, index, next);
/* loop through the entries in the bucket */
while( index != next) {
if(PREDICT_TRUE(memcmp(&bucket->va_entry[index], key,
VA_KEY_SIZE)==0)) {
/* Clear the entry */
FRAG_DEBUG_PRINTF1("Entry found in delete API");
memset(&bucket->va_entry[index], 0, sizeof(va_entry_t));
entry_found = 1;
break;
}
index = (index +1) & VA_BUCKET_MASK;
}
return entry_found;
}
void cnat_va_bucket_used (int argc, unsigned long * argv)
{
u32 i, sum = 0;;
for(i=0;i<VA_BUCKETS;i++) {
if(PREDICT_TRUE(va_bucket[i].new_entry_counter)) sum++;
}
if (PREDICT_FALSE(!sum)) {
printf("no bucket in use\n");
return;
}
printf("index head next counter (%d bucket in use)\n", sum);
for(i=0;i<VA_BUCKETS;i++) {
if (PREDICT_FALSE(!va_bucket[i].new_entry_counter)) continue;
printf(" %04d %04d %04d %d\n", i,
va_bucket[i].head_entry,
va_bucket[i].next_available_entry,
va_bucket[i].new_entry_counter);
}
}
void cnat_va_dump (int argc, unsigned long * argv)
{
u32 i, sum, index ;
PLATFORM_DEBUG_PRINT("====== SUMMARY ======\n");
PLATFORM_DEBUG_PRINT("Total buckets: %d\n", VA_BUCKETS);
PLATFORM_DEBUG_PRINT("Entries per bucket: %d\n", VA_ENTRY_PER_BUCKET);
sum = 0;
for(i=0; i<VA_BUCKETS; i++) {
if (PREDICT_TRUE(va_bucket[i].new_entry_counter > 0)) sum ++;
}
PLATFORM_DEBUG_PRINT("buckets in use: %d\n", sum);
sum = 0;
for(i=0; i<VA_BUCKETS; i++) {
if ( PREDICT_FALSE(((va_bucket[i].next_available_entry+1) & VA_BUCKET_MASK)
== va_bucket[i].head_entry)) {
sum ++;
}
}
PLATFORM_DEBUG_PRINT("bucket full: %d\n", sum);
/* dump per bucket info */
if (argc == 0 ) return;
index = (u32) argv[0];
if (PREDICT_FALSE(index >= VA_BUCKETS)) {
PLATFORM_DEBUG_PRINT("invalid bucket index %d\n", index);
return;
}
PLATFORM_DEBUG_PRINT("\n====== Bucket %d ======\n", index);
PLATFORM_DEBUG_PRINT("bucket head index %d\n", va_bucket[index].head_entry);
PLATFORM_DEBUG_PRINT("bucket next index %d\n", va_bucket[index].next_available_entry);
PLATFORM_DEBUG_PRINT(" source IP dest IP VRF ip-id srcP dstP\n");
for(i=0;i<VA_ENTRY_PER_BUCKET;i++) {
hex_dump((u8*)&va_bucket[index].va_entry[i], sizeof(va_entry_t));
}
}