d7c87db4a565fba1a9c037e6dbe57ac4f5ccee34
[keystone-rtos/netapi.git] / ti / runtime / netapi / test / net_test_utils.c
1 /******************************************
2  * File: net_test_utils.c
3  * Purpose: net_test application general utilities
4  **************************************************************
5  * FILE:  net_test_utils.c
6  * 
7  * DESCRIPTION:  net_test application general utilities
8  * 
9  * REVISION HISTORY:
10  *
11  *  Copyright (c) Texas Instruments Incorporated 2010-2011
12  * 
13  *  Redistribution and use in source and binary forms, with or without 
14  *  modification, are permitted provided that the following conditions 
15  *  are met:
16  *
17  *    Redistributions of source code must retain the above copyright 
18  *    notice, this list of conditions and the following disclaimer.
19  *
20  *    Redistributions in binary form must reproduce the above copyright
21  *    notice, this list of conditions and the following disclaimer in the 
22  *    documentation and/or other materials provided with the   
23  *    distribution.
24  *
25  *    Neither the name of Texas Instruments Incorporated nor the names of
26  *    its contributors may be used to endorse or promote products derived
27  *    from this software without specific prior written permission.
28  *
29  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
30  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
31  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
32  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
33  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
34  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
35  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
36  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
37  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
38  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
39  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
41  *****************************************/
43 #include "net_test_utils.h"
45 #include <stdio.h>
46 #include <stdlib.h>
47 #include <unistd.h>
48 #include <string.h>
49 #include <signal.h>
50 #include <pthread.h>
51 #include "trie.h"
52 #include "router.h"
54 #include <ti/drv/sa/salld.h>
55 #include <ti/drv/pa/pa.h>
57 extern NETAPI_T netapi_handle;
58 extern netTestConfig_t netTestCfg;
59 extern netTestConfig_t config;
60 extern netTestSA_t sa_info[];
61 extern NETAPI_SCHED_HANDLE_T * scheduler[];
62 extern Pktlib_HeapHandle ourHeap;
63 extern NETCP_CFG_IP_T ip_rule[];
64 extern NETCP_CFG_MACIF_T mac[];
65 Trie * our_router;
66 STATS_T stats[TUNE_NETAPI_NUM_CORES];
67 paSysStats_t netcp_stats;
69 //#include "router.c"
74 OUR_ROUTE_T routes[MAX_ROUTES]=
75 {
76 {0,{0xD4,0xbe,0xd9,0x00,0xd3,0x7e, 0x00,0x01,0x02,0x03,0x14,0x02,0x08,0x00},0},
77 {0,{0x00,0x00,0x0,0x00,0x0,0x0, 0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00},0},
78 {0,{0xD4,0xbe,0xd9,0x00,0xd3,0x7e, 0x00,0x01,0x02,0x03,0x14,0x02,0x08,0x00},0},
79 {0,{0x00,0x15,0x60,0xa1,0xf7,0xbe, 0x00,0x01,0x02,0x03,0x04,0x05,0x08,0x00},0},
80 {0,{0xd4,0xbe,0xd9,0x00,0xd3,0x7e, 0x00,0x01,0x02,0x03,0x04,0x05,0x08,0x00},0}};
82 static struct LastPktInfo lpInfo;
83 int check_header(HEAD_T * p_head, PKTIO_METADATA_T * p_meta)
84 {
85 #ifdef MULTI_THREAD
86     int coreid=Osal_nwalGetProcId();  //who we are(thread local)
87     //int coreid = our_core;
88 #else
89     int coreid=0;
90 #endif
91 if (NWAL_RX_FLAG1_META_DATA_VALID & p_meta->u.rx_meta->rxFlag1)
92 {
93     lpInfo.iface = ((unsigned int)p_meta->u.rx_meta->appId) &0xff; //last byte is interface num
94     lpInfo.ipcsum =(p_meta->u.rx_meta->rxFlag1 & NWAL_RX_FLAG1_IPV4_CHKSUM_VERIFY_MASK )== NWAL_RX_FLAG1_IPV4_CHKSUM_VERIFY_ACK ? 1 : 0;
95     lpInfo.l4csum = (p_meta->u.rx_meta->rxFlag1 & NWAL_RX_FLAG1_L4_CHKSUM_VERIFY_MASK )== ((NWAL_RX_FLAG1_L4_CHKSUM_VERIFY_ACK) << NWAL_RX_FLAG1_L4_CHKSUM_VERIFY_SHIFT) ? 1 : 0; 
96     if ((unsigned int)p_meta->u.rx_meta->appId & NETAPI_NETCP_MATCH_IPSEC)
97     {
98     stats[coreid].sec_rx++;
99     }
100     if ((unsigned int)p_meta->u.rx_meta->appId & NETAPI_NETCP_MATCH_IPSEC_POLICY)
101     {
102     stats[coreid].secp_rx++;
103     }
105     if ((unsigned int)p_meta->u.rx_meta->appId & NETAPI_NETCP_MATCH_CLASS)
106     {
107         int c= ((unsigned int)p_meta->u.rx_meta->appId >>8)&0xffff;
108     if (c==0)  stats[coreid].n_class0_rx +=1;
109     else if (c==1) stats[coreid].n_class1_rx +=1;
110     else if (c==2) stats[coreid].n_class2_rx +=1;
111     else netapi_Log("**NET_TEST RX -unknown class: %x\n",  p_meta->u.rx_meta->appId);
115  return 1;
119 static int scnt=0;
120 int QUIT;
121 void mysig(int x)
123     QUIT=1;
124     scnt+=1;
125     netapi_Log(">net_test: recv'd signal %d cnt=%d\n",x,scnt);
126     if (scnt > 10)
127     {
128         netapi_Log(">net_test: WARNING EXITING WITH PROPER SHUTDOWN, LUTS LEFT ACTIVE\n");
129         exit(1);
130     }
132 unsigned long peek(unsigned long * p)
134     return *p;
136 void dump_descr(unsigned long *p, int n)
138     netapi_Log("--------dump of descriptor %d %x\n", n, (int) p);
139     netapi_Log("> %x %x %x %x %x %x %x %x\n",p[0],p[1],p[2],p[3],p[4],p[5],p[6],p[7]);
140     netapi_Log("> %x %x %x %x %x %x %x %x\n",p[8],p[9],p[10],p[11],p[12],p[13],p[14],p[15]);
141     netapi_Log("-----------------------------\n");
143 void dump_header(unsigned long *p, int n, int a, int r)
145     netapi_Log("--------dump of header %d %x appID=%x flag1=%x\n", n, (int) p,a,r);
146     netapi_Log("> %x %x %x %x %x %x %x %x\n",p[0],p[1],p[2],p[3],p[4],p[5],p[6],p[7]);
147     netapi_Log("> %x %x %x %x %x %x %x %x\n",p[8],p[9],p[10],p[11],p[12],p[13],p[14],p[15]);
148     netapi_Log("> %x %x %x %x %x %x %x %x\n",p[16],p[17],p[18],p[19],p[20],p[21],p[22],p[23]);
149     netapi_Log("> %x %x %x %x %x %x %x %x\n",p[24],p[25],p[26],p[27],p[28],p[29],p[30],p[31]);
150     netapi_Log("-----------------------------\n");
153 void  netapi_dump_buf
155     unsigned long *                      buf,
156     uint32_t                      buf_length
159     uint8_t                       count = 0;
160     uint16_t                      dump_size;
161     uint8_t*                     tmp_buf;
162     uint8_t                       row_count;
163     static uint8_t                first = 0;
165     //if(first > 2) return;
167     //first++;
169     dump_size = buf_length ;
171     tmp_buf = (uint8_t *)(buf);
173     netapi_Log("netapi *:  - 8 bit word hex Length: %d Start \n",buf_length);
174     do
175     {
176     row_count = (dump_size - count);
178         if(row_count == 0)
179         {
180             break;
181         }
183         if(row_count > 4)
184         {
185             row_count = 4;
186         }
188         switch (row_count)
189         {
190             case 4:
191             {
192                 netapi_Log("netapi *:%02d : %02x    %02x    %02x    %02x \n",
193                       count,tmp_buf[0],tmp_buf[1],tmp_buf[2],tmp_buf[3]);
194                 break;
195             }
196             case 3:
197             {
198                 netapi_Log("netapi *: %02d : %02x    %02x    %02x \n",
199                       count,tmp_buf[0],tmp_buf[1],tmp_buf[2]);
200                 break;
201             }
203             case 2:
204             {
205                 netapi_Log("netapi *: %02d : %02x    %02x \n",
206                       count,tmp_buf[0],tmp_buf[1]);
207                 break;
208             }
210             case 1:
211             {
212                 netapi_Log("netapi *: %02d : %02x \n",
213                       count,tmp_buf[0]);
214                 break;
215             }
217             default:
218             {
219                 /* Should never reach here */
220                 netapi_Log("netapi *: Internal Error in netapi_dump_buf().Row Count: %d \n", row_count);
221                 return;
222             }
223         }
225         tmp_buf = tmp_buf + row_count;
226         count = count +  row_count;
228     }while(count < dump_size);
230     netapi_Log("netapi *:  - Byte hex Dump End \n");
233 long htonl(long x)
235     long temp = (x&0xff000000)>>24 | (x&0xff0000)>>8 | (x&0xff00)<<8 |  (x&0xff)<<24 ;
236     return temp;
239 unsigned char hex2dec(char *p_s)
241   int val;
242   sscanf(p_s,"%x",&val); 
243  return val&0xff;
246 /********************************************************************
247  *  FUNCTION PURPOSE: Ones complement addition utility
248  ********************************************************************
249  ********************************************************************/
250 uint16_t test_utilOnesComplementAdd (uint16_t v1, uint16_t v2)
252   uint32_t result;
254   result = (uint32_t)v1 + (uint32_t)v2;
255   result = (result >> 16) + (result & 0xffff);
256   result = (result >> 16) + (result & 0xffff);
258   return ((uint16_t)result);
261 /********************************************************************
262  *  FUNCTION PURPOSE: Ones complement checksum utility
263  ********************************************************************
264  ********************************************************************/
265  uint16_t test_utilOnesCompChkSum (uint8_t *p, uint32_t nwords)
267   uint16_t chksum = 0;
268   uint16_t v;
269   uint32_t i;
270   uint32_t j;
272   for (i = j = 0; i < nwords; i++, j+=2)  {
273     v = (p[j] << 8) | p[j+1];
274     chksum = test_utilOnesComplementAdd (chksum, v);
275   }
276   return (chksum);
277 } /* utilOnesCompChkSum */
279 /**************************************************************************************
280  * FUNCTION PURPOSE: Compute ipv4 psudo checksum
281  **************************************************************************************
282  * DESCRIPTION: Compute ipv4 psudo checksum
283  **************************************************************************************/
284 uint16_t test_utilGetIpv4PsudoChkSum (uint8_t *data, uint16_t payloadLen)
286   uint16_t psudo_chksum;
288   psudo_chksum = test_utilOnesCompChkSum (&data[12], 4);
289   psudo_chksum = test_utilOnesComplementAdd(psudo_chksum, (uint16_t) data[9]);
290   psudo_chksum = test_utilOnesComplementAdd(psudo_chksum, payloadLen);
292   return (psudo_chksum);
294 } /* utilGetIpv4PsudoChkSum */
296 #define CHECK_SET_PARAM(ARG1, ARG2)     \
297     do { \
298         if(strcmp(key, ARG1) == 0) { \
299         if(d1)strncpy(ARG2,d1,CONFIG_STRING_LEN); \
300         continue; \
301         } \
302     } while(0)
304 #define CHECK_SET_PARAM2(ARG1, ARG2,  ARG3)     \
305     do { \
306         if(strcmp(key, ARG1) == 0) { \
307         if(d1) strncpy(ARG2,d1,CONFIG_STRING_LEN); \
308         if(d2) strncpy(ARG3,d2,CONFIG_STRING_LEN); \
309         continue; \
310         } \
311     } while(0)
313 #define CHECK_SET_PARAM_SA(ARG1, ARG2, ARG3, ARG4, ARG5, \
314                                                    ARG6, ARG7, ARG8,  ARG9, ARG10, \
315                                                    ARG11, ARG12,ARG13, ARG14, ARG15, ARG16,ARG17, ARG18)     \
316     do { \
317         if(d1) strncpy(ARG2,d1,CONFIG_STRING_LEN); \
318         if(d2) strncpy(ARG3,d2,CONFIG_STRING_LEN); \
319         if(d3) strncpy(ARG4,d3,CONFIG_STRING_LEN); \
320         if(d4) strncpy(ARG5,d4,CONFIG_STRING_LEN); \
321         if(d5) strncpy(ARG6, d5,CONFIG_STRING_LEN); \
322         if(d6) strncpy(ARG7,d6,CONFIG_STRING_LEN); \
323         if(d7) strncpy(ARG8,d7,CONFIG_STRING_LEN); \
324         if(d8) strncpy(ARG9,d8,CONFIG_STRING_LEN); \
325         if(d9) strncpy(ARG10,d9,CONFIG_STRING_LEN); \
326         if(d10) strncpy(ARG11,d10,CONFIG_STRING_LEN); \
327         if(d11) strncpy(ARG12,d11,CONFIG_STRING_LEN); \
328         if(d12) strncpy(ARG13,d12,CONFIG_STRING_LEN); \
329         if(d13) strncpy(ARG14,d13,CONFIG_STRING_LEN); \
330         if(d14) strncpy(ARG15,d14,CONFIG_STRING_LEN); \
331         if(d15) strncpy(ARG16,d15,CONFIG_STRING_LEN); \
332         if(d16) strncpy(ARG17,d16,CONFIG_STRING_LEN); \
333         if(d17) strncpy(ARG18,d17,CONFIG_STRING_LEN); \
334         continue; \
335     } while(0)
337 void print_ipsec_stats(Sa_IpsecStats_t     *p_saIpsecStats, nwal_saAALG auth, nwal_saEALG cipher)
339 #if 0
340     if(retVal != nwal_OK)
341     {
342         System_System_netapi_Log("CORE: %d Error getting IP Sec Stats: Ret Status: %d \n",
343                        retVal);
344         return(nwal_FALSE);
345     }
346     if((p_saIpsecStats->pktEncHi) ||(p_saIpsecStats->pktEncLo))
347     {
348         Debug_netapi_Log("------------- IPSec TX (Encryption Channel) Stats BEGIN --\n");
349     }
350     else
351     {
352         netapi_Log("------------- IPSec RX (Decryption Channel) Stats BEGIN --\n");
353     }
354 #endif
355     netapi_Log("\nAutentication mode: %d, Encryption Mode: %d\n", auth, cipher);
356     netapi_Log("IPSec replayOld:0x%x,replayDup:0x%x,authFail:0x%x \n",
357                    p_saIpsecStats->replayOld,p_saIpsecStats->replayDup,p_saIpsecStats->authFail);
358     netapi_Log("IPSec txESN:0x%x,rxESN:0x%x,pktEncHi:0x%x,pktEncLo:0x%x,pktDecHi:0x%x,pktDecLo:0x%x \n",
359                    p_saIpsecStats->txESN,p_saIpsecStats->rxESN,p_saIpsecStats->pktEncHi,
360                    p_saIpsecStats->pktEncLo,p_saIpsecStats->pktDecHi,p_saIpsecStats->pktDecLo);
363 void print_datamode_stats(Sa_DataModeStats_t     *p_saDataModeStats, nwal_saAALG auth, nwal_saEALG cipher)
366     netapi_Log("\nAutentication mode: %d, Encryption Mode: %d\n", auth, cipher);
367     netapi_Log(" Packets processedHi: 0x%x, Packets processed Lo:0x%x\n",
368             p_saDataModeStats->pktHi, p_saDataModeStats->pktLo);
371 /******************************************************
372  * stats callback
373  *******************************************************/
374 void our_stats_cb_mt(NETAPI_T h, paSysStats_t* pPaStats)
377 #ifdef MULTI_THREAD
378     int coreid=Osal_nwalGetProcId();  //who we are(thread local)
379     //int coreid = our_core;
380 #else
381 int coreid=0;
382 #endif
384   stats[coreid].n_stats_cb +=1;
385   if(pPaStats) memcpy(&netcp_stats,pPaStats, sizeof(paSysStats_t));
387 void our_stats_cb(NETAPI_T h, paSysStats_t* pPaStats)
389 uint32_t numFreeDataPackets;
390 uint32_t            numZeroBufferPackets;
391 uint32_t            numPacketsinGarbage;
392 Pktlib_HeapStats    pktLibHeapStats;
393 int i;
394 unsigned long long bcpp;
395 unsigned long long bcpp_noc;
396 unsigned long long bcpp_app;
397 unsigned long long bcpp_tx;
398 unsigned long long npL;
399 unsigned long long cyclesL;
400 unsigned long long ccyclesL; //cache cycles
401 unsigned long long tmp_npL[TUNE_NETAPI_NUM_CORES];
402 unsigned long long tmp_cyclesL[TUNE_NETAPI_NUM_CORES];
403 unsigned long long tmp_ccyclesL[TUNE_NETAPI_NUM_CORES]; //cache cycles
404 NETAPI_SA_STATS_T netapi_sa_stats;
406     for (i=0;i < TUNE_NETAPI_NUM_CORES;i++)
407     {
408         printf("Per Core Statistics for CORE %d\n", i);
409         printf(">*****stats @ %lld (#cbs%d) \n", hplib_mUtilGetTimestamp(),stats[i].n_stats_cb);
410         printf(">itx=%d rx=%d tx=%d bad=%d slow=%d \n>rx_class0=%d rx_class1=%d rx_class2=%dsecRx=%d\t"
411             "secPRX=%d sb_rx=%d sb_tx=%d auth_ok=%d sec_tx=%d  min_rx=%d min_tx=%d  fragPkt=%d, exceptionPktOther=%d\n",
412          stats[i].itx, stats[i].rx, stats[i].tx, stats[i].n_bad, stats[i].n_new, 
413          stats[i].n_class0_rx, stats[i].n_class1_rx,  stats[i].n_class2_rx, stats[i].sec_rx,
414          stats[i].secp_rx, stats[i].sb_rx, stats[i].sb_tx, stats[i].n_auth_ok,
415          stats[i].sec_tx, stats[i].rx_min, stats[i].tx_min, stats[i].exceptionPktsFrag, stats[i].exceptionPktsOther);
416         printf(">if rx stats:  %d %d %d\n",stats[i].if_rx[0],stats[i].if_rx[1],stats[i].if_rx[2]);
417         printf(">core rx stats:  %d \n",stats[i].core_rx);
419         if (stats[i].rx && stats[i].tx)
420             printf("decrypt time per packet(avg): %lu, encrypt  time per packet(avg): %lu\n", 
421             (unsigned long) stats[i].total_decrypt_time/stats[i].rx, (unsigned long) stats[i].total_encrypt_time/stats[i].tx);
424         if (npL && stats[i].rx)
425         {
426             bcpp = cyclesL/npL; 
427             bcpp_noc = (cyclesL-ccyclesL)/npL; 
428             bcpp_app = (stats[i].app_cycles-stats[i].tx_cache_cycles)/stats[i].rx;
429         }
430         else
431         {
432             bcpp = bcpp_noc=bcpp_app=0L;
433         }
434         if (stats[i].tx)
435         {
436             bcpp_tx = (stats[i].send_cycles-stats[i].tx_cache_cycles)/stats[i].tx;
437         }
438         else
439         {
440             bcpp_tx = 0L;
441         }
442         printf(">         ++ busy cycles pp=%lld (%lld wo cache ops) (app+tx= %lld) (tx= %lld) ++\n",
443          bcpp,bcpp_noc,bcpp_app, bcpp_tx);
444         printf("\n");
445     }
447 #ifdef MULTI_THREAD
448     for (i=0;i < TUNE_NETAPI_NUM_CORES;i++)
449     {
450         if(scheduler[i])
451         {
452             netapi_schedGetStats(scheduler[i],&tmp_npL[0],&tmp_cyclesL[0],&tmp_ccyclesL[0]);
453             npL = tmp_npL[0]+tmp_npL[1];
454             cyclesL = tmp_cyclesL[0]+tmp_cyclesL[1];
455             ccyclesL = tmp_ccyclesL[0]+tmp_ccyclesL[1];
456         }
457     }
458 #else
459 netapi_schedGetStats(our_sched, &npL,&cyclesL,&ccyclesL);
460 #endif
462 if(pPaStats)
464        printf("C1 number of packets:           %d\n", pPaStats->classify1.nPackets);
465        printf("C1 number IPv4 packets:         %d\n", pPaStats->classify1.nIpv4Packets);
466        printf("C1 number IPv6 packets:        %d\n", pPaStats->classify1.nIpv6Packets);
467        printf("C1 number Custom packets:        %d\n", pPaStats->classify1.nCustomPackets);
468        printf("C1 number SRIO packets:        %d\n", pPaStats->classify1.nSrioPackets);
469        printf("C1 number LLC/SNAP Fail packets:        %d\n", pPaStats->classify1.nLlcSnapFail);
470        printf("C1 number table matched:        %d\n", pPaStats->classify1.nTableMatch);
471        printf("C1 number failed table matched: %d\n", pPaStats->classify1.nNoTableMatch);
472        printf("C1 number IP Fragmented packets: %d\n", pPaStats->classify1.nIpFrag);
473        printf("C1 number IP Depth Overflow: %d\n", pPaStats->classify1.nIpDepthOverflow);
474        printf("C1 number VLAN Depth Overflow: %d\n", pPaStats->classify1.nVlanDepthOverflow);
475        printf("C1 number GRE Depth Overflow: %d\n", pPaStats->classify1.nGreDepthOverflow);
476        printf("C1 number MPLS Packets: %d\n", pPaStats->classify1.nMplsPackets);
477        printf ("C1 number of parse fail:        %d\n",pPaStats->classify1.nParseFail);
478        printf("C1 number of Invalid IPv6 Opt:  %d\n", pPaStats->classify1.nInvalidIPv6Opt);
479        printf("C1 number of TX IP Fragments:  %d\n", pPaStats->classify1.nTxIpFrag);
480        printf ("C1 number of silent discard:    %d\n",pPaStats->classify1.nSilentDiscard);
481        printf("C1 number of invalid control:   %d\n", pPaStats->classify1.nInvalidControl);
482        printf ("C1 number of invalid states:    %d\n",pPaStats->classify1.nInvalidState);
483        printf ("C1 number of system fails:      %d\n",pPaStats->classify1.nSystemFail);
484        printf ("C2 number Packets  :           %d\n",pPaStats->classify2.nPackets);
485        printf ("C2 number udp           :      %d\n",pPaStats->classify2.nUdp);
486        printf ("C2 number tcp           :      %d\n",pPaStats->classify2.nTcp);
487        printf ("C2 number Custom       :      %d\n",pPaStats->classify2.nCustom);
488        printf ("C2 number silent drop   :      %d\n",pPaStats->classify2.nSilentDiscard);
489        printf ("C2 number invalid cntrl :      %d\n\n",pPaStats->classify2.nInvalidControl);
490        printf ("C2 number Modify Stats Cmd Fail :      %d\n\n",pPaStats->modify.nCommandFail);
492 Pktlib_getHeapStats(ourHeap, &pktLibHeapStats);
493 printf("main heap stats>  #free=%d #zb=%d #garbage=%d\n", pktLibHeapStats.numFreeDataPackets,
494                                 pktLibHeapStats.numZeroBufferPackets, pktLibHeapStats.numPacketsinGarbage);
495 printf("               >  #dataBufThreshStatus=%d #dataBufStarvCounter=%d #zBufThreshStatus=%d #zBufStarvCounter=%d \n", 
496                         pktLibHeapStats.dataBufferThresholdStatus,pktLibHeapStats.dataBufferStarvationCounter,
497                         pktLibHeapStats.zeroDataBufferThresholdStatus, pktLibHeapStats.zeroDataBufferStarvationCounter);
499 #if 0
500 netapi_Log("pa2sa descriptor area dump\n");
501 for(i=0;i<TUNE_NETAPI_CONFIG_MAX_PA_TO_SA_DESC;i++)
503    extern long * pa2sa_descr_base;
504    long * tip= &pa2sa_descr_base[32*i]; 
505    dump_descr(tip, i);
507 netapi_Log("sa2pa descriptor area dump\n");
508 for(i=0;i<TUNE_NETAPI_CONFIG_MAX_SA_TO_PA_DESC;i++)
510    extern long * sa2pa_descr_base;
511    long * tip= &sa2pa_descr_base[32*i]; 
512    dump_descr(tip, i);
514 #endif
515     for (i = 0; i < netTestCfg.num_sa; i++)
516     {
517         /* Statistics for RX Tunnel */
518         memset(&netapi_sa_stats, 0, sizeof(netapi_sa_stats));
519         if (sa_info[i].dir ==NWAL_SA_DIR_INBOUND )
520         {
521             netapi_getSaStats(netapi_handle, sa_info[i].rx_tunnel, &netapi_sa_stats);
522             if (netapi_sa_stats.validParams & NETAPI_IPSEC_STAT_VALID)
523             {
524                 print_ipsec_stats(&(netapi_sa_stats.saIpsecStats), 
525                                  sa_info[i].authMode,
526                                  sa_info[i].cipherMode);
527             }
528             if (netapi_sa_stats.validParams & NETAPI_SIDEBAND_DATA_MODE_STAT_VALID)
529             {
530                 print_datamode_stats(&(netapi_sa_stats.dataModeStats),
531                                    sa_info[i].authMode,
532                                    sa_info[i].cipherMode);
533             }
534         }
535         else if (sa_info[i].dir ==NWAL_SA_DIR_OUTBOUND)
536         {
537             netapi_getSaStats(netapi_handle, sa_info[i].tx_tunnel, &netapi_sa_stats);
538             if (netapi_sa_stats.validParams & NETAPI_IPSEC_STAT_VALID)
539             {
540                  print_ipsec_stats(&(netapi_sa_stats.saIpsecStats), 
541                                    sa_info[i].authMode,
542                                    sa_info[i].cipherMode);
543             }
544             if (netapi_sa_stats.validParams & NETAPI_SIDEBAND_DATA_MODE_STAT_VALID)
545             {
546                 print_datamode_stats(&(netapi_sa_stats.dataModeStats),
547                                     sa_info[i].authMode,
548                                     sa_info[i].cipherMode);
549             }
550         }
551         else
552             netapi_Log("our_stats_cb: invalid SA direction\n");
553     }
554     netapi_dump_internal_heap_stats();
558 void parse_one_mac(char * p_mac_str, unsigned char *p_mac)
560     int index = 0;
561     int i;
562     char *pch = strtok (&(p_mac_str[0]),"-");
564     while (pch != NULL)
565     {
566         p_mac[index] = hex2dec(pch);
567         index++;
568         pch = strtok (NULL,"-");
569     }
573 void parse_one_key(char *p_key_str, unsigned char *p_key)
575     int index = 0;
576     int i;
577      char * pch = strtok (&p_key_str[0],",");
579     while (pch != NULL)
580     {
581         p_key[index] = hex2dec(pch);
582         index++;
583         pch = strtok (NULL,",");
584     }
587 void parse_one_ip(char * p_ip_addr_str, unsigned char * p_ip)
589     int index = 0;
590     int i;
591     char * pch = strtok (&p_ip_addr_str[0],".");
593     while (pch != NULL)
594     {
595         p_ip[index] = atoi(pch);
596         index++;
597         pch = strtok (NULL,".");
598     }
601 void parse_mac_address(netTestConfigFile_t *pConfig)
603     int i;
604     int port = 0;
605     for(i=0;i<NET_TEST_MAX_MAC;i++)
606     {
607         if (strlen(&pConfig->mac[i][0]))
608         {
609             netTestCfg.num_macs++;
610             parse_one_mac(&pConfig->mac[i][0],&netTestCfg.mac[i][0]);
611             sscanf(&pConfig->switch_port[i][0],"sp%d",&netTestCfg.switch_port[i]);
612         }
613     }
614     netapi_Log("parse_mac_address: number of mac address %d\n", netTestCfg.num_macs);
617 void parse_ip_address(netTestConfigFile_t *pConfig)
619     int i;
621     for(i=0;i<NET_TEST_MAX_IP;i++)
622     {
623         if (strlen(&pConfig->ip[i][0]))
624         {
625             netTestCfg.num_ips++;
626             parse_one_ip(&pConfig->ip[i][0],&netTestCfg.ip[i].ipv4[0]);
627             sscanf(&pConfig->attach_iface[i][0],"mac%d",&netTestCfg.attach_iface[i]);
628         }
629     }
630     netapi_Log("parse_ip_address: number of ip address %d\n", netTestCfg.num_ips);
632 void parse_ipsec_mode(netTestConfigFile_t *pConfig)
635     if (strlen(&pConfig->ipsec_mode_rx[0]))
636     {
637         if (strcmp(pConfig->ipsec_mode_rx, "SIDEBAND") == 0)
638         {
639             netTestCfg.ipsec_mode_rx = IPSEC_MODE_RX_SIDEBAND;
640         }
641         else if (strcmp(pConfig->ipsec_mode_rx, "INFLOW") == 0)
642         {
643             netTestCfg.ipsec_mode_rx = IPSEC_MODE_RX_INFLOW;
644         }
645         else
646         {
647             netapi_Log("parse_ipsec_mode(), invalid RX ipsec mode in config file \n");
648         }
649     }
651     if (strlen(&pConfig->ipsec_mode_tx[0]))
652     {
653         if (strcmp(pConfig->ipsec_mode_tx, "SIDEBAND") == 0)
654         {
655             netTestCfg.ipsec_mode_tx = IPSEC_MODE_TX_SIDEBAND;
656         }
657         else if (strcmp(pConfig->ipsec_mode_tx, "INFLOW") == 0)
658         {
659             netTestCfg.ipsec_mode_tx = IPSEC_MODE_TX_INFLOW;
660         }
661         else
662         {
663             netapi_Log("parse_ipsec_mode(), invalid TX ipsec mode in config file \n");
664         }
665     }
669 void parse_auth_mode(char *auth_mode_str, nwal_saAALG *auth_mode)
671     if (strlen(auth_mode_str))
672     {
673         netapi_Log("strlen of auth_mode_str is %d\n", strlen(auth_mode_str));
675         if (strcmp(auth_mode_str, "NULL") == 0)
676         {
677             *auth_mode= NWAL_SA_AALG_NULL;
678         }
679         else if (strcmp(auth_mode_str, "HMAC_MD5") == 0)
680         {
681             *auth_mode= NWAL_SA_AALG_HMAC_MD5;
682         }
683         else if (strcmp(auth_mode_str, "HMAC_SHA1") == 0)
684         {
685             *auth_mode= NWAL_SA_AALG_HMAC_SHA1;
686         }
687         else if (strcmp(auth_mode_str, "HMAC_SHA2_224") == 0)
688         {
689             *auth_mode= NWAL_SA_AALG_HMAC_SHA2_224;
690         }
691         else if (strcmp(auth_mode_str, "HMAC_SHA2_256") == 0)
692         {
693             *auth_mode= NWAL_SA_AALG_HMAC_SHA2_256;
694         }
695         else if (strcmp(auth_mode_str, "GMAC") == 0)
696         {
697             *auth_mode= NWAL_SA_AALG_GMAC;
698         }
699         else if (strcmp(auth_mode_str, "AES_XCBC") == 0)
700         {
701             *auth_mode= NWAL_SA_AALG_AES_XCBC;
702         }
703         else
704         {
705             netapi_Log("parse_auth_mode: invalid auth mode specified\n");
706         }
707     }
710 void parse_encr_mode(char *ency_mode_str, nwal_saEALG*encr_mode)
712     if (strlen(ency_mode_str))
713     {
714         if (strcmp(ency_mode_str, "NULL") == 0)
715         {
716             *encr_mode= NWAL_SA_EALG_NULL;
717         }
718         else if (strcmp(ency_mode_str, "AES_CTR") == 0)
719         {
720             *encr_mode= NWAL_SA_EALG_AES_CTR;
721         }
722         else if (strcmp(ency_mode_str, "AES_CBC") == 0)
723         {
724             *encr_mode= NWAL_SA_EALG_AES_CBC;
725         }
726         else if (strcmp(ency_mode_str, "3DES_CBC") == 0)
727         {
728             *encr_mode= NWAL_SA_EALG_3DES_CBC;
729         }
730         else if (strcmp(ency_mode_str, "AES_CCM") == 0)
731         {
732             *encr_mode= NWAL_SA_EALG_AES_CCM;
733         }
734         else if (strcmp(ency_mode_str, "AES_GCM") == 0)
735         {
736             *encr_mode= NWAL_SA_EALG_AES_GCM;
737         }
738         else if (strcmp(ency_mode_str, "AES_XCBC") == 0)
739         {
740             *encr_mode= NWAL_SA_AALG_AES_XCBC;
741         }
742         else
743         {
744             netapi_Log("parse_encr_mode: invalid auth mode specified\n");
745         }
746     }
749 void parse_proto(char *proto_str, nwal_IpSecProto *proto)
751     if (strlen(proto_str))
752     {
753         if (strcmp(proto_str, "ESP") == 0)
754         {
755             *proto= nwal_IpSecProtoESP;
756             netapi_Log("parse_proto(): setting proto  to ESP\n");
757         }
758         else if (strcmp(proto_str, "AH") == 0)
759         {
760             *proto = nwal_IpSecProtoAH;
761             netapi_Log("parse_proto(): setting proto to AH\n");
762         }
763         else
764         {
765             netapi_Log("parse_proto(), invalid RX ipsec mode in config file \n");
766         }
767     }
772 void parse_mode(char *mode_str, nwal_saMode *mode)
774     if (strlen(mode_str))
775     {
776         if (strcmp(mode_str, "TUNNEL") == 0)
777         {
778             *mode= nwal_SA_MODE_TUNNEL;
779         }
780         else if (strcmp(mode_str, "TRANSPORT") == 0)
781         {
782             *mode = nwal_SA_MODE_TRANSPORT;
783         }
784         else
785         {
786             netapi_Log("parse_mode(), invalid RX ipsec mode in config file \n");
787         }
788     }
791 void parse_ipType(char *ip_type_str, nwal_IpType *ipType)
793     if (strlen(ip_type_str))
794     {
795         if (strcmp(ip_type_str, "IPV4") == 0)
796         {
797             *ipType= nwal_IPV4;
798         }
799         else if (strcmp(ip_type_str, "IPV6") == 0)
800         {
801             *ipType = nwal_IPV6;
802         }
803         else
804         {
805             netapi_Log("parse_ipType(), invalid RX ipsec mode in config file \n");
806         }
807     }
810 void parse_spi(char *spi_str, uint32_t *spi)
812     if (strlen(spi_str))
813     {
814         *spi = (int)strtol(spi_str, NULL, 0);
815     }
818 void parse_replayWindow(char *replay_window_str, uint32_t *replay_window)
820     *replay_window = atoi(replay_window_str);
823 void parse_esn(char *esn_str, uint32_t *esn)
825     *esn = atoi(esn_str);
828 void parse_key_size(char *key_size_str, uint16_t *key_size)
830     *key_size = atoi(key_size_str);
833 void parse_tunnel_id(char * tunnel_id_str, uint32_t *tunnel_id)
835     if (strlen(tunnel_id_str))
836     {
837         *tunnel_id = (int)strtol(tunnel_id_str, NULL, 0);
838     }
841 void parse_dir(char* dir_str, nwal_SaDir *dir)
843     if (strlen(dir_str))
844     {
845         if (strcmp(dir_str, "INBOUND") == 0)
846         {
847             *dir= NWAL_SA_DIR_INBOUND;
848         }
849         else if (strcmp(dir_str, "OUTBOUND") == 0)
850         {
851             *dir = NWAL_SA_DIR_OUTBOUND;
852         }
853         else
854             netapi_Log("parse_dir: invalid direction\n");
855     }
857 void parse_one_fp(char * p_fp_str, uint8_t* start, uint8_t* end)
859     int index = 0;
860     int i;
862     char *pch = strtok (&(p_fp_str[0]),"-");
863     *start = atoi(pch);
864     pch = strtok (NULL,"-");
865     *end = atoi(pch);
866     netapi_Log("parse_one_fp: start %d, end %d\n", *start, *end);
870 void parse_sp(netTestConfigFile_t *pConfig)
872     int i;
873     int port = 0;
874     for(i=0;i<NET_TEST_MAX_FP_THREAD;i++)
875     {
876         if (strlen(&pConfig->sp[i][0]))
877         {
878             netTestCfg.num_sp_threads++;
879             parse_one_fp(&pConfig->sp[i][0],(uint8_t*)&netTestCfg.sp_proc_start[i], (uint8_t*)&netTestCfg.sp_proc_end);
880         }
881         if (strlen(&pConfig->sp_thread_num[i][0]))
882         {
883             netTestCfg.sp_thread_num[i] = atoi((char*)(&pConfig->sp_thread_num[i]));
884             netapi_Log("parse_sp: thread_num[%d]: %d\n", i, netTestCfg.sp_thread_num[i]);
885         }
886     }
887     netapi_Log("parse_sp: number of sp threads  %d\n", netTestCfg.num_sp_threads);
892 void parse_fp(netTestConfigFile_t *pConfig)
894     int i;
895     int port = 0;
896     for(i=0;i<NET_TEST_MAX_FP_THREAD;i++)
897     {
898         if (strlen(&pConfig->fp[i][0]))
899         {
900             netTestCfg.num_fp_threads++;
901             parse_one_fp(&pConfig->fp[i][0],(uint8_t*)&netTestCfg.fp_proc_start[i], (uint8_t*)&netTestCfg.fp_proc_end);
902         }
903         if (strlen(&pConfig->fp_thread_num[i][0]))
904         {
905             netTestCfg.fp_thread_num[i] = atoi((char*)(&pConfig->fp_thread_num[i]));
906             netapi_Log("parse_fp: thread_num[%d]: %d\n", i, netTestCfg.fp_thread_num[i]);
907         }
908     }
909     netapi_Log("parse_fp: number of fp threads  %d\n", netTestCfg.num_fp_threads);
914 void parse_ipsec_if_no(netTestConfigFile_t *pConfig)
916     if (strlen(&pConfig->ipsec_if_no[0]))
917     {
918         netTestCfg.ipsec_if_no= atoi(&pConfig->ipsec_if_no[0]);
919         netapi_Log("parse_ipsec_if_no %d\n",netTestCfg.ipsec_if_no);
920     }
923 void parse_sa(netTestConfigFile_t *pConfig, int i)
925     parse_dir((char*) &pConfig->sa_config[i].dir, &netTestCfg.sa_info[i].dir);
926     parse_spi((char*)&pConfig->sa_config[i].spi, &netTestCfg.sa_info[i].spi);
927     parse_proto((char*)&pConfig->sa_config[i].proto, &netTestCfg.sa_info[i].proto);
928     parse_mode((char*)&pConfig->sa_config[i].saMode, &netTestCfg.sa_info[i].saMode);
929     parse_ipType((char*)&pConfig->sa_config[i].ipType, &netTestCfg.sa_info[i].ipType);
930     parse_one_ip((char*)&pConfig->sa_config[i].src, (unsigned char *)&netTestCfg.sa_info[i].src);
931     parse_one_ip((char*)&pConfig->sa_config[i].dst, (unsigned char *)&netTestCfg.sa_info[i].dst);
932     parse_replayWindow((char*)&pConfig->sa_config[i].replayWindow, &netTestCfg.sa_info[i].replayWindow);
933     parse_auth_mode((char*)&pConfig->sa_config[i].authMode, &netTestCfg.sa_info[i].authMode);
934     parse_encr_mode((char*)&pConfig->sa_config[i].cipherMode, &netTestCfg.sa_info[i].cipherMode);
935     parse_esn((char*)&pConfig->sa_config[i].esnLo, &netTestCfg.sa_info[i].esnLo);
936     parse_esn((char*)&pConfig->sa_config[i].esnHi, &netTestCfg.sa_info[i].esnHi);
937     parse_key_size((char*)&pConfig->sa_config[i].encKeySize, &netTestCfg.key_params[i].encKeySize);
938     parse_key_size((char*)&pConfig->sa_config[i].macKeySize, &netTestCfg.key_params[i].macKeySize);
941     parse_one_key((char*) &pConfig->sa_config[i].encr_key, &netTestCfg.encr_key[i][0]);
942     netTestCfg.key_params[i].pEncKey = (uint8_t*)&netTestCfg.encr_key[i][0];
944     parse_one_key((char*)&pConfig->sa_config[i].auth_key, &netTestCfg.auth_key[i][0]);
945     netTestCfg.key_params[i].pAuthKey= (uint8_t*)&netTestCfg.auth_key[i][0];
948     parse_tunnel_id((char*)&pConfig->sa_config[i].tunnel_id, &netTestCfg.tunnel_id[i]);
950    netTestCfg.num_sa++;
951    printf("**************************** parse sa: num_sa %d\n", netTestCfg.num_sa);
955 int n_routes=0;
956 int n_dst_ips=0;
957 void parse_routes(netTestConfigFile_t *pConfig)
959     int i;
960     int said=0;
961     for(i=0;i<MAX_ROUTES;i++)
962     {
963         int port;
964         if (pConfig->routes[i][0])
965         {
966             port=atoi(&pConfig->ports[i][0]);
967           if((port<1)||(port>2)) continue; //bad port #: only 1 or 2 valid
968           netapi_Log("parse_routes [%d]: %s\n", i, &pConfig->routes[i][0]);
969           if(strncmp(&pConfig->routes[i][0],"MAC",3)==0)
970           {
971              routes[i].out_port = port;
972              parse_one_mac(&pConfig->routes[i][3],&routes[i].out_mac[0]);
973              //memcpy(&routes[i].out_mac[6], ((port==1) ?&config.mac0[0]: &config.mac1[0] ),6); 
974              memcpy(&routes[i].out_mac[6], ((port==1) ?&netTestCfg.mac[0][0]: &netTestCfg.mac[1][0] ),6);
975              routes[i].out_mac[12]=0x08;
976              routes[i].out_mac[13]=0x00;
977              routes[i].sec_ptr=NULL;
978              n_routes+=1;
979           }
980           else if (strncmp(&pConfig->routes[i][0],"SA",2)==0)
981           {      
982              said=atoi(&pConfig->routes[i][2]) ;
983              routes[i].sec_ptr=&sa_info[said];
984              n_routes+=1;
985           }
986        }
987     }
988     our_router = route_init();
989     for (i=0;i<MAX_ROUTES;i++)
990     {
991       unsigned long ip_be;
992       int route_index;
993       if (pConfig->dst_ips[i][0])
994       {
995          parse_one_ip(&pConfig->dst_ips[i][0],(unsigned char *)&ip_be);
996          sscanf(&pConfig->paths[i][0],"route%d",&route_index);
997          route_add(our_router,&ip_be,(void*)&routes[route_index]);
998          n_dst_ips+=1;
999       }
1000     }
1001 //netapi_Log(">Route DB built.  %d entries\n",n_dst_ips);
1004 void parse_config_file(FILE * fpr, netTestConfigFile_t *pConfig)
1006     char line[MAX_LINE_LENGTH + 1];
1007     int i;
1008     static int sa_count = 0;
1009  
1010     char *key, *ep;
1011     char * d1, *d2, *d3, *d4;
1012     char * d5, *d6, *d7, *d8;
1013     char * d9, *d10, *d11, *d12;
1014     char * d13, *d14, *d15, *d16, *d17;
1015     char tokens[] = " :=;\n";
1016     char temp_str[50];
1017     memset(line, 0, MAX_LINE_LENGTH + 1);
1018     memset(pConfig, 0, sizeof(netTestConfigFile_t));
1019     while (fgets(line, MAX_LINE_LENGTH + 1, fpr))
1020     {
1021         if(line[0]=='#')
1022             continue; //skip comment
1023         key  = (char *)strtok(line, tokens);
1025         d1 = (char *)strtok(NULL, tokens);
1026         if (!key)
1027             continue;
1028         if (!d1) 
1029             continue;
1031         if(strlen(d1) == 0) 
1032         {
1033             continue;
1034         }
1037         d2 = (char *)strtok(NULL, tokens);
1038         d3 = (char *)strtok(NULL, tokens);
1039         d4 = (char *)strtok(NULL, tokens);
1040         d5 = (char *)strtok(NULL, tokens);
1041         d6 = (char *)strtok(NULL, tokens);
1042         d7 = (char *)strtok(NULL, tokens);
1043         d8 = (char *)strtok(NULL, tokens);
1044         d9 = (char *)strtok(NULL, tokens);
1045         d10 = (char *)strtok(NULL, tokens);
1046         d11 = (char *)strtok(NULL, tokens);
1047         d12 = (char *)strtok(NULL, tokens);
1048         d13 = (char *)strtok(NULL, tokens);
1049         d14 = (char *)strtok(NULL, tokens);
1050         d15 = (char *)strtok(NULL, tokens);
1051         d16 = (char *)strtok(NULL, tokens);
1052         d17 = (char *)strtok(NULL, tokens);
1054          CHECK_SET_PARAM(INIT_CONFIG_IPSEC_MODE_RX,&(pConfig->ipsec_mode_rx[0]));
1055          CHECK_SET_PARAM(INIT_CONFIG_IPSEC_MODE_TX,&(pConfig->ipsec_mode_tx[0]));
1056          CHECK_SET_PARAM(INIT_CONFIG_IPSEC_IF_NO,&(pConfig->ipsec_if_no[0]));
1057          //CHECK_SET_PARAM(INIT_CONFIG_NUM_FP_CORES,&(pConfig->num_fp_cores[0]));
1058          //CHECK_SET_PARAM(INIT_CONFIG_NUM_FP_THREADS,&(pConfig->num_fp_threads[0]));
1059          
1060         sprintf(temp_str,"sa%d",sa_count);
1061         if(strcmp(key, temp_str) == 0)
1062         {
1063             netapi_Log("parse_config_file, temp_str %s, sa_count: %d\n", temp_str, sa_count);
1064             CHECK_SET_PARAM_SA(temp_str, 
1065                                                 (char*)&pConfig->sa_config[sa_count].dir,
1066                                                 (char*)&pConfig->sa_config[sa_count].spi,
1067                                                 (char*)&pConfig->sa_config[sa_count].proto,
1068                                                 (char*)&pConfig->sa_config[sa_count].saMode,
1069                                                 (char*)&pConfig->sa_config[sa_count].ipType,
1070                                                 (char*)&pConfig->sa_config[sa_count].src,
1071                                                 (char*)&pConfig->sa_config[sa_count].dst,
1072                                                 (char*)&pConfig->sa_config[sa_count].replayWindow,
1073                                                 (char*)&pConfig->sa_config[sa_count].authMode,
1074                                                 (char*)&pConfig->sa_config[sa_count].cipherMode,
1075                                                 (char*)&pConfig->sa_config[sa_count].esnLo,
1076                                                 (char*)&pConfig->sa_config[sa_count].esnHi,
1077                                                 (char*)&pConfig->sa_config[sa_count].encKeySize,
1078                                                 (char*)&pConfig->sa_config[sa_count].macKeySize,
1079                                                 (char*)&pConfig->sa_config[sa_count].encr_key,
1080                                                 (char*)&pConfig->sa_config[sa_count].auth_key,
1081                                                 (char*)&pConfig->sa_config[sa_count].tunnel_id);
1082             parse_sa(pConfig,sa_count);
1083             sa_count++;
1084             continue;
1085         }
1087 #ifdef EXPERIMENTAL
1088         for(i=0;i<MAX_ROUTES;i++)
1089         {
1090             sprintf(temp_str,"route%d",i);
1091             CHECK_SET_PARAM2(temp_str,&pConfig->routes[i][0],&pConfig->ports[i][0] );
1092         }
1094         for(i=0;i<MAX_ROUTES;i++)
1095         {
1096             sprintf(temp_str,"dstip%d",i);
1097             CHECK_SET_PARAM2(temp_str,&pConfig->dst_ips[i][0],&pConfig->paths[i][0] );
1098         }
1099 #endif
1100         for(i=0;i<NET_TEST_MAX_MAC;i++)
1101         {
1102             sprintf(temp_str,"mac%d",i);
1103             CHECK_SET_PARAM2(temp_str,&pConfig->mac[i][0],&pConfig->switch_port[i][0] );
1104         }
1105         for(i=0;i<NET_TEST_MAX_IP;i++)
1106         {
1107             sprintf(temp_str,"ip%d",i);
1108             CHECK_SET_PARAM2(temp_str,&pConfig->ip[i][0], &pConfig->attach_iface[i][0]);
1109         }
1110         for(i=0;i<2;i++)
1111         {
1112             sprintf(temp_str,"fp%d",i);
1113             CHECK_SET_PARAM2(temp_str, &pConfig->fp_thread_num[i][0],&pConfig->fp[i][0]);
1114         }
1115         for(i=0;i<2;i++)
1116         {
1117             sprintf(temp_str,"sp%d",i);
1118             CHECK_SET_PARAM2(temp_str, &pConfig->sp_thread_num[i][0],&pConfig->sp[i][0]);
1119         }
1120     }
1121     parse_mac_address(pConfig);
1123     parse_fp(pConfig);
1124     parse_sp(pConfig);
1126     parse_ip_address(pConfig);
1128     parse_ipsec_mode(pConfig);
1131 #ifdef EXPERIMENTAL
1132     parse_routes(pConfig);
1133 #endif
1135      parse_ipsec_if_no(pConfig);
1136     //parse_num_fp_cores(pConfig);
1137     //parse_num_fp_threads(pConfig);
1141 //******************************************************
1142 //use scheduling housekeeping callback to generate pkts
1143 //******************************************************
1144 static int done_burst=0;
1145 void house(NETAPI_SCHED_HANDLE_T * s)
1147     Ti_Pkt * tip;
1148     unsigned int len;
1149     nwalTxPktInfo_t meta_tx = {0};
1150     PKTIO_METADATA_T meta = {PKTIO_META_TX,{0},0};
1151     int err;
1152     static int house_pkts_gened=0;
1153     int p;
1154     unsigned char * pIpHdr,* pData;
1155     unsigned int vv1,vv2,vv3;
1156     unsigned int sum_vv1=0;
1157     unsigned int sum_vv2=0;
1158     unsigned int sum_vv3=0;
1159     unsigned int sum_vv4=0;
1160     unsigned int sum_vv5=0;
1162     unsigned int nwal_flow_vv1,nwal_flow_vv2;
1163     unsigned int nwal_sum_vv1=0;
1164     unsigned int nwal_sum_vv2=0;
1165     unsigned int nwal_sum_vv3=0;
1166     unsigned int nwal_sum_vv4=0;
1167     unsigned int nwal_sum_vv5=0;
1168     unsigned int nwal_sum_vv6=0;
1170     unsigned int nwal_sum_flow_vv1=0;
1171     unsigned int nwal_sum_flow_vv2=0;
1172     unsigned long long cache_op_b1;
1173     unsigned long long  cache_op_b2;
1174     unsigned long long  n_c_ops;
1175     static int first =0;
1176     Cppi_HostDesc*      pPktDesc;
1177     NETAPI_SCHED_SHUTDOWN_T sched_shutdown;
1179     uint32_t coreid = 0;  //who we are
1180 #ifdef MULTI_THREAD
1181     NETAPI_T nh= netapi_schedGetHandle(s);
1182     coreid=(uint32_t) netapi_getCookie(nh);
1184     if (QUIT) 
1185     {
1186         sched_shutdown.shutdown_type = NETAPI_SCHED_SHUTDOWN_NOW;
1187         netapi_schedClose(s,&sched_shutdown,&err); 
1188         return;
1189     }
1191     
1192     /* only slow path threads get netcp stats */
1193     if (coreid & NET_TEST_SP_THREAD_MASK)
1194     {
1195         netapi_netcpCfgReqStats(nh, our_stats_cb_mt, 0,&err); 
1196     }
1198     coreid = NET_TEST_THREAD_NUM_MASK & coreid;
1199 #else
1200     coreid = NET_TEST_THREAD_NUM_MASK & coreid;
1201     if(done_burst)
1202     {
1203         house_pkts_gened+=TX_BURST;
1204         netapi_Log("net_test> request stats at n=%d \n",house_pkts_gened);
1205         netapi_netcpCfgReqStats(netapi_handle, our_stats_cb, 0,&err);
1206         if (err!=0) {netapi_Log("stats req failed\n");}
1207         if (house_pkts_gened >= np2process+ 100)
1208         {
1209             sched_shutdown.shutdown_type = NETAPI_SCHED_SHUTDOWN_NOW;
1210             netapi_schedClose(s,&sched_shutdown,&err);
1211         }
1212         return;
1213     }
1214     done_burst=1;
1215     Osal_cache_op_measure_reset();
1216     memset(&meta_tx,0,sizeof(meta_tx));
1217     for(p=0;p<TX_BURST;p++) {  
1218     //reguest stats 
1219     if ((house_pkts_gened>0) && (! (house_pkts_gened%1000)) )
1220     {
1221        netapi_Log("net_test> request stats at n=%d \n",house_pkts_gened);
1222        netapi_netcpCfgReqStats(netapi_handle, our_stats_cb, 0,&err); 
1223        if (err!=0) {netapi_Log("stats req failed\n");}
1224     }
1227     if (house_pkts_gened >= np2process+ 100)
1228     {
1229         //shutdown
1230         sched_shutdown.shutdown_type = NETAPI_SCHED_SHUTDOWN_NOW;
1231         netapi_schedClose(s,&sched_shutdown,&err);
1232         continue;
1233     }
1235     else if (house_pkts_gened >= np2process) { house_pkts_gened+=1;  continue;}
1237     /* manufacture a pkt to transmit */
1238     tip = get_pkt(house_pkts_gened, &len, ourHeap, PKT_LEN,&testPkt[0]  , TEST_PKT_LEN);
1239     if(!tip) { house_pkts_gened +=1; continue; }
1242     /* set the pkt length */
1243     vv1 = hplib_mUtilGetPmuCCNT();
1244     Pktlib_setPacketLen(tip, len);
1246     /* set up meta data */
1247     meta.sa_handle=nwal_HANDLE_INVALID;
1248     /* #define BENCH_UDP_SEND */
1249 #ifdef BEND_UDP_SEND
1250     meta_tx.txFlag1 = (NWAL_TX_FLAG1_DO_IPV4_CHKSUM | NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID);
1251     meta_tx.startOffset = 0;
1252     /* GONE in V2 meta_tx.pktLen = len; */
1253     meta_tx.ipOffBytes = TEST_PKT_IP_OFFSET_BYTES;
1254     meta_tx.l4OffBytes = TEST_PKT_UDP_OFFSET_BYTES;
1255     meta_tx.l4HdrLen = TEST_PKT_UDP_HDR_LEN;
1256     //GONE in V2 meta_tx.ploadOffBytes = TEST_PKT_PLOAD_OFFSET_BYTES;
1257     meta_tx.ploadLen = TEST_PAYLOAD_LEN;
1259     Pktlib_getDataBuffer(tip,&pData,&len);
1260     if(house_pkts_gened &0x1)
1261     {
1262         memcpy(&pData[6],&netTestCfg.mac[1][0] ,6);
1263     }
1264     pIpHdr = pData + meta_tx.ipOffBytes;
1265     meta_tx.pseudoHdrChecksum =
1266         test_utilGetIpv4PsudoChkSum(pIpHdr,(TEST_PAYLOAD_LEN+TEST_PKT_UDP_HDR_LEN));
1267 #else
1268     Pktlib_getDataBuffer(tip,&pData,&len);
1269     if(house_pkts_gened &0x1)
1270     {
1271         memcpy(&pData[6],&netTestCfg.mac[1][0] ,6);
1272     }
1273     meta_tx.txFlag1 = NWAL_TX_FLAG1_META_DATA_VALID;
1274     meta_tx.startOffset = 0;
1275     meta_tx.ploadLen = TEST_PAYLOAD_LEN;
1276 #endif
1277    /* post it to netcp tx channel*/
1278    meta.u.tx_meta=&meta_tx;
1279 #ifdef DEBUG_DESC
1280     if (house_pkts_gened<16) dump_descr((long *) tip, house_pkts_gened);
1281     else if (house_pkts_gened>99) dump_descr((long *) tip,house_pkts_gened);
1282 #endif
1284     if(!first)
1285     {
1286         first++;
1287         nwal_flow_vv1= hplib_mUtilGetPmuCCNT();
1288         if(nwal_initPSCmdInfo(pktio_mGetNwalInstance(netcp_tx_chan),
1289                              &meta_tx,
1290                              &flowPSCmdInfo) != nwal_OK)
1291         {
1292             netapi_Log("nwal_initPSCmdInfo() ERROR \n");
1293         }
1294         nwal_flow_vv2= hplib_mUtilGetPmuCCNT();
1295         nwal_sum_flow_vv1 += (nwal_flow_vv1-vv1); 
1296         nwal_sum_flow_vv2 += (nwal_flow_vv2-nwal_flow_vv1); 
1297     }
1298     cache_op_b1= Osal_cache_op_measure(&n_c_ops);
1299     vv2= hplib_mUtilGetPmuCCNT();
1300 #ifdef BEND_UDP_SEND
1301     nwal_mCmdSetL4CkSumPort(  tip,
1302                              &flowPSCmdInfo,
1303                              TEST_PKT_UDP_OFFSET_BYTES,
1304                              (TEST_PKT_UDP_HDR_LEN + TEST_PAYLOAD_LEN),
1305                              meta_tx.pseudoHdrChecksum,
1306                              meta_tx.enetPort);
1307 #else
1308     nwal_mCmdSetPort  (tip,
1309                       &flowPSCmdInfo,  //could be NULL
1310                       0);  //port 0 -> switch decides
1312 #endif
1314     pPktDesc = Pktlib_getDescFromPacket(tip);
1315     /* Send the packet out to transmit Q*/
1316     Qmss_queuePushDescSize (flowPSCmdInfo.txQueue, 
1317                         pPktDesc, 
1318                         NWAL_DESC_SIZE);
1319     vv3= hplib_mUtilGetPmuCCNT();
1320     cache_op_b2= Osal_cache_op_measure(&n_c_ops);
1322     sum_vv1 += (vv2-vv1);
1323     if(!house_pkts_gened)
1324     {
1325         /* first packet. Take out the PS command label creation cost */
1326         sum_vv1 = sum_vv1 - nwal_sum_flow_vv2;
1327     }
1329     sum_vv3 += (vv3-vv2)-(long) (cache_op_b2-cache_op_b1); //sub out cache op cost
1331     // netapi_Log("pktio send. full=%d metadata=%d pktio_send=%d\n", vv3-vv1,  vv2-vv1,  vv3-vv2);
1332     stats[coreid].itx +=1;
1333     house_pkts_gened +=1;
1334     }
1335     {
1336         unsigned long long  ccycles;
1337         ccycles =Osal_cache_op_measure(&n_c_ops);
1338         if (sum_vv1) 
1339         {
1340             netapi_Log("BURST NWAL Fast send %d pkts.  metadata=%d Cmd Label Creation Cost=%d  nwal Fast Send Cost (less cacheop)= %d n_c_ops=%lld cache_op_time=%lld (pp-> %d)\n", 
1341               stats[coreid].itx, sum_vv1/stats[coreid].itx,  nwal_sum_flow_vv2, sum_vv3/stats[coreid].itx, 
1342               n_c_ops, ccycles, n_c_ops? (ccycles/(n_c_ops/2L)) : 0);
1343 #if 0
1344             netapi_Log("NWAL Profile Cycles: Prof1= %d,Prof2=%d,Prof3=%d,Prof4=%d,Prof5=%d ,Prof6=%d \n",
1345               nwal_sum_vv1/stats[coreid].itx,nwal_sum_vv2/stats[coreid].itx,nwal_sum_vv3/stats[coreid].itx,
1346               nwal_sum_vv4/stats[coreid].itx,nwal_sum_vv5/stats[coreid].itx,nwal_sum_vv6/stats[coreid].itx);
1347   
1348 #endif  
1350             if(stats[core_id].itx2)
1351             {
1352                 netapi_Log("nwal_flowSend Profile Cycles: Prof1= %d,Prof2=%d \n",
1353                 nwal_sum_flow_vv1/stats[coreid].itx2,nwal_sum_flow_vv2/stats[coreid].itx2);
1354             }
1355         }
1356     }
1357 #endif
1360 void create_interfaces(void)
1362     int err, i;
1364     for (i = 0; i < netTestCfg.num_macs; i++)
1365     {
1366         /* add mac intefaces */
1367         mac[i] = netapi_netcpCfgCreateMacInterface(
1368                           netapi_handle,
1369                           &netTestCfg.mac[i][0],
1370                           i,
1371                           netTestCfg.switch_port[i],
1372                           (NETCP_CFG_ROUTE_HANDLE_T)  NULL,
1373                           (NETCP_CFG_VLAN_T ) NULL ,  //future
1374                           1, 
1375                           &err);
1376        if (err)
1377        {
1378             netapi_Log("addmac %d  failed %d\n",i, err);
1379         //exit(1); 
1380        }
1381        else
1382         netapi_Log("create_interfaces, added mac sucess\n");
1383     }
1384     for (i = 0; i < netTestCfg.num_ips; i++)
1385     {
1386         //attach an IP to this interface
1387         ip_rule[i]=netapi_netcpCfgAddIp(
1388                           netapi_handle,
1389                           netTestCfg.attach_iface[i],
1390                           nwal_IPV4,
1391                           (nwalIpAddr_t  *)&netTestCfg.ip[i].ipv4[0],
1392                           NULL,  //all IP
1393                           (NETCP_CFG_ROUTE_HANDLE_T) NULL,
1394                           (void*)NULL,
1395                           &err
1396                           );
1397         if (err) {
1398             netapi_Log("addip %d failed %d\n", i, err);
1399         //exit(1); 
1400         }
1401         else
1402             netapi_Log("create_interfaces, added ip sucess\n");
1403     }
1406 void delete_interfaces(void)
1408     int err,i;
1409     //delete IPs and MAC Interfacess
1410     for (i = 0; i < netTestCfg.num_ips; i++)
1411     {
1412         err = 0;
1413         netapi_netcpCfgDelIp(netapi_handle, netTestCfg.attach_iface[i], nwal_IPV4, 
1414                       NULL, NULL, ip_rule[i], &err);
1415     }
1416     for (i = 0; i < netTestCfg.num_macs; i++)
1417     {
1418         err = 0;
1419         netapi_netcpCfgDelMac(netapi_handle,i,&err);
1420     }
1421     
1422     //netapi_netcpCfgDelMac(netapi_handle,0,&err);
1423     //netapi_netcpCfgDelMac(netapi_handle,1,&err);