/*
 *------------------------------------------------------------------
 * spp_platform_trace_log.c 
 *
 * Copyright (c) 2008-2011, 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 <vlib/vlib.h>
#include <stdio.h>
#include <vppinfra/vec.h>
#include <vppinfra/bitmap.h>
#include <vppinfra/hash.h>
#include <vppinfra/pool.h>
#include <vppinfra/clib.h>
#include <vlib/main.h>

#include "tcp_header_definitions.h"
#include "platform_common.h"
#include "spp_platform_trace_log.h"

#define WORD_SIZE sizeof(u32)

int temperature_read_blocked = 1;

spp_cnat_logger_tbl_t spp_cnat_logger_table[] =
{
  { CNAT_ERROR_SUCCESS,
    3,
    0,
    {"i-vrf",
    "ipv4 addr",
     "port"}
  },
  { CNAT_NO_CONFIG_ERROR,
    3,
    180,
    {"i-vrf",
    "ipv4 addr",
     "port"}
  },
  { CNAT_NO_VRF_RUN_ERROR,
    3,
    180,
    {"i-vrf",
    "ipv4 addr",
     "port"}
  },
  { CNAT_NO_POOL_FOR_ANY_ERROR,
    3,
    180,
    {"i-vrf",
    "ipv4 addr",
     "port"}
  },
  { CNAT_NO_PORT_FOR_ANY_ERROR,
    3,
    60,
    {"i-vrf",
    "ipv4 addr",
     "port"}
  },
  { CNAT_BAD_INUSE_ANY_ERROR,
    3,
    60,
    {"i-vrf",
    "ipv4 addr",
     "port"}
  },
  { CNAT_NOT_FOUND_ANY_ERROR,
    3,
    60,
    {"i-vrf",
    "ipv4 addr",
     "port"}
  },
  { CNAT_INV_PORT_FOR_DIRECT_ERROR,
    3,
    60,
    {"i-vrf",
    "ipv4 addr",
     "port"}
  },
  { CNAT_BAD_INUSE_DIRECT_ERROR,
    3,
    1,
    {"i-vrf",
    "ipv4 addr",
     "port"}
  },
  { CNAT_NOT_FOUND_DIRECT_ERROR,
    3,
    1,
    {"i-vrf",
    "ipv4 addr",
     "port"}
  },
  { CNAT_OUT_OF_PORT_LIMIT_ERROR,
    3,
    60,
    {"i-vrf",
    "ipv4 addr",
     "port"}
  },
  { CNAT_MAIN_DB_CREATE_ERROR, 
    0,
    30,
    {""}
  },
  { CNAT_LOOKUP_ERROR,
    1,
    30,
    {"Type"}
  },
  { CNAT_INDEX_MISMATCH_ERROR,
    2,
    30,
    {"in2out_index",
     "out2in_index"}
  },
  { CNAT_PACKET_DROP_ERROR,
    3,
    15,
    {"i-vrf",
    "ipv4 addr",
     "port"}
  },
  { CNAT_INV_UNUSED_USR_INDEX,
    1,
    10,
    {"invalid/unused user index"}
  },
  { CNAT_INVALID_VRFMAP_INDEX,
    0,
    60,
    {""}
  },
  { CNAT_USER_OUT_OF_PORTS,
    2,
    1800,
    {"i-vrf",
     "ipv4 addr"}
  },
  { CNAT_EXT_PORT_THRESH_EXCEEDED,
    2,
    180,
    {"i-vrf",
     "ipv4 address"}
  },
  { CNAT_EXT_PORT_THRESH_NORMAL,
    2,
    180,
    {"vrf",
     "ipv4 address"}
  },
  { CNAT_NO_EXT_PORT_AVAILABLE,
    0,
    1,
    {"",}
  },
  { CNAT_SESSION_THRESH_EXCEEDED,
    2,
    1800, 
    {"vrf",
     "ipv4 address"}
  },
  { CNAT_SESSION_THRESH_NORMAL,
    2,
    30, /* changed to 30 */
    {"vrf",
     "ipv4 address"}
  },
  { WQE_ALLOCATION_ERROR,
    0,
    180, /* changed to 180 */
    {""}
  },
  { ERROR_PKT_DROPPED,
    2,
    60, /* changed to 60 */
    {"spi-port",
     "error-code"}
  },
  { SYSMGR_PD_KEY_CREATION_ERROR,
    0,
    30,
    {""}
  },
  { SYSMGR_PD_SHMEM_ID_ERROR,
    0,
    1,
    {""}
  },
  { SYSMGR_PD_SHMEM_ATTACH_ERROR,
    0,
    1,
    {""}
  },
  { OCTEON_CKHUM_SKIPPED,
    2,
    60, /* changed to 60 */
    {"version",
     "protocol"}
  },
  { PK0_SEND_STATUS,
    1,
    15,
    {"status"}
  },
  { CMD_BUF_ALLOC_ERR,
    0,
    60,
    {""}
  },
  { SPP_CTX_ALLOC_FAILED,
    1,
    300, /* every 5 min  */
    {"node"}
  },
  { SPP_MAX_DISPATCH_REACHED,
    1,
    60,
    {"node"}
  },
  { HA_SIGCHILD_RECV,
    3,
    1,
    {"pid",
    "uid",
     "signal",}
  },
  { SIGACTION_ERR,
    0,
    1,
    {""}
  },
  { HA_INVALID_SEQ_OR_CONFIG_OR_TYPE,
    2,
    10,
    {"seq-id or config option",
     "Type"}
  },
  { NODE_CREATION_ERROR,
    1,
    1,
    {"node"}
  },

  { CNAT_CLI_INVALID_INPUT,
      4,
      0,
    {"Error Type",
      "Passed",
      "Expected",
     "Type"}
  },
  { CNAT_DUMMY_HANDLER_HIT,
      1,
      0,
    {"Handler"}
  },
  { CNAT_CONFIG_ERROR,
      5,
      0,
    {"Sub code",
      "Param 1",
      "Param 2",
      "Param 3",
     "Param 4"}
  },
  { CNAT_NFV9_ERROR,
      1,
      180, /* changed to 180 */
    {"Sub code"}
  },
  { CNAT_CMVX_TWSI_READ_WRITE_FAIL,
     3,
     180,
    {"Operation",
     "Location",
     "Data"}
  },
  { CNAT_TEMP_SENSOR_TIMEOUT,
      0,
      180,
    {""}
  },
  { CNAT_TEMP_SENSOR_DATA_MISMATCH,
      2,
      180,
    {"Actual",
     "Expected"}
  },
  { CNAT_TEMP_SENSOR_CONFIG_FAILED,
      1,
      180,
    {"Glik"}
  },
  { HA_APP_NOT_RESPONDING,
      2,
      180,
    {"CPU",
     "Core"}
  },
  { HA_DATA_PATH_TEST_FAILED,
      0,
      30,
    {""}
  },
  { CNAT_WRONG_PORT_ALLOC_TYPE,
      3,
      60,
    {"i-vrf",
      "ipv4 addr",
     "port"}
  },
  { CNAT_NEW_PORT_ALLOC_ERROR,
      3,
      60,
    {"i-vrf",
      "ipv4 addr",
     "port"}
  },
  { CNAT_INVALID_INDEX_TO_FREE_PORT,
      0,
      60,
    {""}
  },
  { CNAT_DELETE_DB_ENTRY_NO_PORTMAP,
      0,
      60,
    {""}
  },
  { CNAT_MAIN_DB_LIMIT_ERROR,
      0,
      180,
    {""}
  },
  { CNAT_USER_DB_LIMIT_ERROR,
      0,
      180,
    {""}
  },
  { CNAT_FRAG_DB_ERROR,
      1,
      180,
    {"Type"}
  },

  { DROP_PKT_DUMP,
    0,
    20,
    {""}
  }
};

#define LOG_TABLE_MAX_ENTRIES \
   (sizeof(spp_cnat_logger_table)/sizeof(spp_cnat_logger_table[0]))

u32 error_code_timestamps[LOG_TABLE_MAX_ENTRIES];
spp_timer_t sensor_timer;
spp_trace_log_global_info_t spp_trace_log_global_info;
spp_global_counters_t spp_global_counters;

/*
 * Logging information structures
 */
spp_trace_log_info_t spp_default_trace_log_info;
spp_trace_log_info_t *spp_trace_log_info_pool;

#ifdef TOBE_PORTED
/*
 * The following 2 functions are temporary hacks until
 * we have RTC support from the PD nodes
 */
inline
u32 spp_trace_log_get_sys_up_time_in_ms (void)
{
    spp_node_main_vector_t *nmv;
    u32 sys_up_time;

    nmv = spp_get_node_main_vectorized_inline();
		    
    sys_up_time = (u32) (nmv->ticks / nmv->ticks_per_ms);

    return (sys_up_time);
}

u32 spp_trace_log_get_unix_time_in_seconds (void)
{
    spp_node_main_vector_t *nmv;
    u32 unix_time;

    nmv = spp_get_node_main_vectorized_inline();
		    
    unix_time = (u32) (nmv->ticks / nmv->ticks_per_second);

    return (unix_time);
}

/*
 * edt: * * spp_trace_log_send_queued_pkt
 *
 * Tries to send a logging pkt that has been queued earlier
 * because it could not be sent due to downstream constipation
 *
 * Argument: spp_trace_log_info_t *trace_logging_info
 * structure that contains the packet context
 */
inline
void spp_trace_log_send_queued_pkt (spp_trace_log_info_t *trace_logging_info)
{
    spp_node_t                  *output_node;

    output_node = spp_get_nodes() + 
       	spp_trace_log_global_info.spp_trace_log_disp_node_index;

    if (PREDICT_TRUE(output_node->sf.nused < SPP_MAXDISPATCH)) {
        /*
         * Move the logging context to output node
         */
        spp_dispatch_make_node_runnable(output_node);
        output_node->sf.ctxs[output_node->sf.nused++] = 
            trace_logging_info->queued_logging_context;

        /*
         * Context has been queued, it will be freed after the pkt
         * is sent.  Clear this from the logging_context_info structure
         */
	    trace_logging_info->queued_logging_context = NULL;

    } else {
	    /*
	     * Can't do much, just return, may be we can send it later
	     */
        spp_global_counters.spp_trace_log_downstream_constipation_count++;
    }
}

/*
 * edt: * * spp_trace_log_send_pkt
 *
 * Tries to send a logging pkt.  If the packet cannot be sent
 * because of rewrite_output node cannot process it, queue
 * it temporarily and try to send it later.
 *
 * Argument: spp_trace_log_info_t *trace_logging_info
 * structure that contains the packet context
 */
inline
void spp_trace_log_send_pkt (spp_trace_log_info_t *trace_logging_info)
{
    spp_node_t                  *output_node;


    output_node = spp_get_nodes() + 
     	spp_trace_log_global_info.spp_trace_log_disp_node_index;

    if (PREDICT_TRUE(output_node->sf.nused < SPP_MAXDISPATCH)) {
        /*
         * Move the logging context to output node
         */
        spp_dispatch_make_node_runnable(output_node);
        output_node->sf.ctxs[output_node->sf.nused++] = 
            trace_logging_info->current_logging_context;

    } else {
     	/*
	     * Queue the context into the logging_info structure,
	     * We will try to send it later.  Currently, we will
         * restrict to only one context queued.
	     */
        spp_global_counters.spp_trace_log_downstream_constipation_count++;

	    /*
	     * Attach the current logging context which is full to the
	     * queued context list in trace_logging_info structure
	     */
	    trace_logging_info->queued_logging_context =
	            trace_logging_info->current_logging_context;

	    /*
	     * Whether the context is queued or not, set the current context index
	     * to EMPTY, as the earlier context can no more be used to send
	     * more logging records.
	     */
    }

    trace_logging_info->current_logging_context = NULL;
}

/*
 * edt: * * spp_trace_log_send_pkt_always_success
 *
 * Tries to send a logging pkt.  This cannot fail due to downstream
 * constipation because we have already checked if the rewrite_output
 * node can accept it.
 *
 * Argument: spp_trace_log_info_t *trace_logging_info
 * structure that contains the packet context
 *
 * Argument: spp_node_t *output_node
 * spp_node_t structure for rewrite_output node
 */
inline
void spp_trace_log_send_pkt_always_success (
                         spp_trace_log_info_t *trace_logging_info,
                         spp_node_t               *output_node)
{
    /*
     * At this point we either have a current or queued logging context
     */
    if (PREDICT_TRUE(trace_logging_info->current_logging_context != NULL)) { 

    	output_node->sf.ctxs[output_node->sf.nused++] = 
	    trace_logging_info->current_logging_context;

        trace_logging_info->current_logging_context = NULL;
    } else {
    	/*
     	 * For queued logging context
	     */
	    output_node->sf.ctxs[output_node->sf.nused++] = 
	         trace_logging_info->queued_logging_context;

	    trace_logging_info->queued_logging_context = NULL;
    }

    /*
     * Move the logging context to output node
     */
    spp_dispatch_make_node_runnable(output_node);

}

/*
 * edt: * * spp_create_trace_log_context
 *
 * Tries to create a logging context with packet buffer
 * to send a new logging packet
 *
 * Argument: spp_trace_log_info_t *trace_logging_info
 * structure that contains the nfv9 logging info and will store
 * the packet context as well.
 */
inline
void spp_create_trace_log_context (
                              spp_trace_log_info_t *trace_logging_info)
{
    spp_ctx_t *ctx;

    /*
     * If queued_logging_context_index is non-EMPTY, we already have a logging
     * packet queued to be sent.  First try sending this before allocating
     * a new context.  We can have only one active packet context per
     * trace_logging_info structure
     */
    if (PREDICT_FALSE(trace_logging_info->queued_logging_context != NULL)) {
        spp_trace_log_send_queued_pkt(trace_logging_info);
        /*
         * If we cannot still send the queued pkt, just return 
         * Downstream Constipation count would have increased anyway
         */
        if (trace_logging_info->queued_logging_context != NULL) {
	        spp_global_counters.spp_trace_log_context_creation_deferred_count++;
	        return;
        }
    }


    /*
     * No context can be allocated, return silently
     * calling routine will handle updating the error counters
     */
    if (spp_ctx_alloc(&ctx, 1) < 1) {
        spp_global_counters.spp_trace_log_context_creation_fail_count++;
	    return;
    }

    trace_logging_info->current_logging_context = ctx;
    trace_logging_info->pkt_length = 0;

    trace_logging_info->current_logging_context_timestamp =
                       spp_trace_log_get_sys_up_time_in_ms();

    ctx->flags = SPP_CTX_END_OF_PACKET;
    ctx->ru.tx.from_node = NODE_TRACE_BACKUP;
    ctx->ru.tx.dst_ip_port_idx = EXT_TRACE_BACKUP_INDEX;
    ctx->next_ctx_this_packet = (spp_ctx_t*) SPP_CTX_NO_NEXT_CTX;
    ctx->current_header = &ctx->packet_data[SPP_TRACE_LOG_HDR_OFFSET];
    ctx->current_length = 0;

    trace_logging_info->log_record = 0;
    trace_logging_info->total_record_count = 0;
    trace_logging_info->next_data_ptr = 
        (u8 *) &ctx->packet_data[SPP_TRACE_LOG_HDR_OFFSET];

}

/*
 * edt: * * spp_trace_log_add_record_create
 *
 * Tries to create an add record to the NFV9 packet
 *
 * Argument: spp_trace_log_info_t *trace_logging_info
 * structure that contains the nfv9 logging info and will store
 * the packet context as well.
 */
inline
void spp_trace_log_add_record_create (spp_trace_log_info_t *trace_logging_info)
{

    trace_logging_info->log_header =
    (spp_trace_log_hdr_t *) (trace_logging_info->next_data_ptr);

    /*
     * Initialize the number of traces recorded
     */
    trace_logging_info->log_header->num_traces =
    spp_host_to_net_byte_order_32(0);


    trace_logging_info->log_record  =
    (spp_trace_log_t *) (trace_logging_info->log_header + 1);

    /*
     * Update the length of the total pkt 
     */
    trace_logging_info->pkt_length +=
        SPP_LOG_TRACE_HEADER_LENGTH; 

    /*
     * Set the data pointer beyond the trace header field
     */
    trace_logging_info->next_data_ptr =
        (u8 *) (trace_logging_info->log_header + 1);

}

/*
 * edt: * * spp_trace_logger
 *
 * Tries to log  spp/cnat event/errors
 *
 * Argument: u8 *error_code
 *  Error code passed
 *
 * Argument: optional arguments
 */
void spp_trace_logger (u16 error_code, u16 num_args, u32 *arg)
{
    spp_trace_log_info_t *trace_logging_info = 0; 
    u8 i;

    trace_logging_info = 
        spp_trace_log_info_pool + 
        spp_trace_log_global_info.spp_log_pool_index[SPP_LOG_LTRACE];

    if (PREDICT_FALSE(trace_logging_info->current_logging_context == NULL)) {
        spp_create_trace_log_context(trace_logging_info);

	    /*
	     * If still empty, return after increasing the count
	     */
	    if (PREDICT_FALSE(trace_logging_info->current_logging_context == NULL)) {
	        return;
	    }
    }

    if (PREDICT_FALSE(trace_logging_info->log_record == NULL)) {
        spp_trace_log_add_record_create(trace_logging_info);
    }

    /*
     * We should definitely have add_record now, no need to sanitize
     */
    trace_logging_info->log_record->error_code = 
		    spp_host_to_net_byte_order_16(error_code);
    trace_logging_info->log_record->num_args = 
		    spp_host_to_net_byte_order_16(num_args);

    for (i = 0; i < num_args; i++) {
        trace_logging_info->log_record->arg[i] = 
                spp_host_to_net_byte_order_32(*(arg + i));
    }

    trace_logging_info->pkt_length += SPP_TRACE_LOG_RECORD_LENGTH + WORD_SIZE*num_args;
    trace_logging_info->current_logging_context->current_length =
                  trace_logging_info->pkt_length;
    trace_logging_info->total_record_count += 1;

    trace_logging_info->next_data_ptr =
        (u8 *) (trace_logging_info->next_data_ptr + WORD_SIZE + WORD_SIZE*num_args);

    trace_logging_info->log_record = 
           (spp_trace_log_t *) (trace_logging_info->next_data_ptr);

    /*
     * Initialize the number of traces recorded
     */
    trace_logging_info->log_header->num_traces =
             spp_host_to_net_byte_order_32(trace_logging_info->total_record_count);



    /*
     * If we have exceeded the packet length, let us send the
     * packet now.  There is buffer of additional bytes beyond
     * max_pkt_length to ensure that the last add/delete record
     * can be stored safely.
     */
    if (trace_logging_info->pkt_length > 
            trace_logging_info->max_length_minus_max_record_size) {
	    spp_trace_log_send_pkt(trace_logging_info);
    }
}


/*
 * edt: * * spp_trace_log_timer_handler
 *
 * Timer handler for sending any pending NFV9 record
 *
 * Argument: spp_timer_t * timer_p
 * Timer handler structure
 */
inline 
void spp_trace_log_timer_handler (spp_timer_t * timer_p)
{
    spp_node_t *output_node;
    spp_trace_log_info_t *trace_logging_info = 0;
    u32 current_timestamp = spp_trace_log_get_sys_up_time_in_ms();
    i16 sf_nused;
    
    output_node = spp_get_nodes() + 
	              spp_trace_log_global_info.spp_trace_log_disp_node_index;

    sf_nused = output_node->sf.nused;

    pool_foreach (trace_logging_info, spp_trace_log_info_pool, ({
        /*
         * Check if no more logging contexts can be queued
         */
	    if (PREDICT_FALSE(sf_nused >= SPP_MAXDISPATCH)) {
	        break;
	    }

	    /*
	     * If there is a current logging context and timestamp
	     * indicates it is pending for long, send it out
	     * Also if there is a queued context send it out as well
	     */
        if (trace_logging_info->queued_logging_context ||
            (trace_logging_info->current_logging_context &&
	        (current_timestamp - 
	         trace_logging_info->current_logging_context_timestamp) 
	                                                        > 1000)) {
            spp_trace_log_send_pkt_always_success(trace_logging_info,
                                                    output_node);
            sf_nused++;
        }
    }));

    timer_p->expires =
        spp_timer_in_n_ms_inline(1000); /* every 1 sec */
    spp_timer_start(timer_p);

}
inline
void spp_sensor_timer_handler (spp_timer_t * timer_p)
{
#ifdef TARGET_RODDICK
    if (!temperature_read_blocked) {
        Init_temperature_sensors();
        read_octeon_sensors(TEMPERATURE_SENSOR_QUIET_MODE);
    }

    timer_p->expires =
                spp_timer_in_n_ms_inline(60000); /* every 1 sec */
    spp_timer_start(timer_p);

#endif
}
void init_trace_log_buf_pool (void)
{   
    spp_trace_log_info_t *my_spp_log_info;
    u8            found;
    spp_log_type_t log_type;

    /* 
     * Init SPP logging info as needed, this will be done only once
     */
    spp_trace_log_init();

    found = 0;

    for (log_type = SPP_LOG_LTRACE; log_type < SPP_LOG_MAX; log_type++ ) {
        /* Do we already have a map for this log type? */
        pool_foreach (my_spp_log_info, spp_trace_log_info_pool, ({
            if (my_spp_log_info->log_type == log_type) {
                found = 1;
                break;
            }
        }));

        /*
         * Entry not present
         */
        if (!found) {
            pool_get(spp_trace_log_info_pool, my_spp_log_info);
            memset(my_spp_log_info, 0, sizeof(*my_spp_log_info));

            /*
             * Make the current and head logging context indeices as EMPTY.
             * When first logging happens, these get set correctly
             */
            my_spp_log_info->current_logging_context = NULL;
            my_spp_log_info->queued_logging_context  = NULL;

            my_spp_log_info->log_type = log_type;
            my_spp_log_info->max_length_minus_max_record_size =
                                SPP_TRACE_LOG_MAX_PKT_LENGTH;

            spp_trace_log_global_info.spp_log_pool_index[log_type] = 
                           my_spp_log_info - spp_trace_log_info_pool;
        }

    }

    return;
}


/*
 * one time function
 * has to be called at the init time
 */
void spp_trace_log_init (void)
{
    if (!spp_trace_log_global_info.spp_trace_log_init_done) {

#ifdef TARGET_RODDICK
   	    spp_trace_log_global_info.spp_trace_log_disp_node_index =
	         spp_lookup_node_index("roddick_infra_l3_tx");
#elif defined(TARGET_BOOSTER)
   	    spp_trace_log_global_info.spp_trace_log_disp_node_index =
	         spp_lookup_node_index("booster_infra_l3_tx");
#endif
	    ASSERT(spp_trace_log_global_info.spp_trace_log_disp_node_index != (u16)~0);

	    spp_trace_log_global_info.log_timer.cb_index = 
	    spp_timer_register_callback(spp_trace_log_timer_handler);
	    spp_trace_log_global_info.log_timer.expires = 
	         spp_timer_in_n_ms_inline(1000); /* every 1 sec */
	    spp_timer_start(&spp_trace_log_global_info.log_timer);

        if (!my_core_id) {
            sensor_timer.cb_index =
                    spp_timer_register_callback(spp_sensor_timer_handler);
            sensor_timer.expires =
                    spp_timer_in_n_ms_inline(60000); /* every 1 sec */
            spp_timer_start(&sensor_timer);
        }

	    spp_trace_log_global_info.spp_trace_log_init_done = 1;

        /*
         *  Set MSC ip_addr, port values
         */
#ifdef TARGET_RODDICK
        dst_ipv4_port_table[EXT_TRACE_BACKUP_INDEX].ipv4_address =
                                        vpp_boot_params.msc_ip_address;
        switch(vpp_boot_params.octeon_number) {
            case 0:
                    dst_ipv4_port_table[EXT_TRACE_BACKUP_INDEX].port = 0x15BF;
                    break;
            case 1:
                    dst_ipv4_port_table[EXT_TRACE_BACKUP_INDEX].port = 0x15BF;
                    break;
            case 2:
                    dst_ipv4_port_table[EXT_TRACE_BACKUP_INDEX].port = 0x15BF;
                    break;
            case 3:
                    dst_ipv4_port_table[EXT_TRACE_BACKUP_INDEX].port = 0x15BF;
                    break;
        }
#else
        dst_ipv4_port_table[EXT_TRACE_BACKUP_INDEX].ipv4_address = 0x01020304;
        dst_ipv4_port_table[EXT_TRACE_BACKUP_INDEX].port = 0x15BF;
#endif

    }
}

void spp_printf (u16 error_code, u16 num_args, u32 *arg)
{
    u32 current_timestamp;
    spp_node_main_vector_t *nmv;

    if (PREDICT_FALSE(error_code >= LOG_TABLE_MAX_ENTRIES))
    {
       /*  printf("Error code invalid %d, %d, %d, %d\n",
            error_code, LOG_TABLE_MAX_ENTRIES,
            sizeof(spp_cnat_logger_table), sizeof(spp_cnat_logger_table[0]));
            */
        return; /* Should not happen */
    }

    nmv = spp_get_node_main_vectorized_inline();
    current_timestamp = nmv->ticks / nmv->ticks_per_second;

    /* Check if any further hashing is required */

    if (PREDICT_FALSE(error_code == DUMP_PKT_IDX)) {
#ifdef TARGET_RODDICK || defined(TARGET_BOOSTER)
        spp_trace_logger(error_code, num_args, arg);
#else
        u8 j ;

        printf("PKT DUMP :: ");
        for (j = 0 ; j < num_args; j++) {
            printf("0x%x ", arg[j]);
            if (j == (num_args - 1)) {
                printf("\n");
            }
        }
#endif
    } else if (PREDICT_TRUE((current_timestamp - error_code_timestamps[error_code]) >=  
               spp_cnat_logger_table[error_code].rate_limit_time)) {
        /* update timestamp */
        error_code_timestamps[error_code] = current_timestamp;

#ifdef TARGET_RODDICK || defined(TARGET_BOOSTER)
        spp_trace_logger(error_code, num_args, arg);     
#else
        u8 j ;
   
        for (j = 0 ; j < num_args; j++) {
            printf("%s: %d ", spp_cnat_logger_table[error_code].param_name[j], arg[j]);
            if (j == (num_args - 1)) {
                printf("\n");
            }
        }
#endif
    }
}
    
#else /* TOBE_PORTEED */
void spp_trace_logger(u16 error_code, u16 num_args, u32 *arg)
{
  /* To be filled */
}

void spp_trace_log_init(void)
{
  /* To be filled */
}

void init_trace_log_buf_pool(void)
{
  /* To be filled */
}

void spp_printf(u16 error_code, u16 num_args, u32 *arg)
{
  /* To be filled */
}

inline u32 spp_trace_log_get_unix_time_in_seconds (void)
{
    vlib_main_t  *vlib_main;

    vlib_main = vlib_get_main();
    return(vlib_time_now((vlib_main_t *) vlib_main));
}

#endif /* TOBE_PORTED */

