Update for crash and compilation fix for latest in the branch
[keystone-rtos/netapi.git] / ti / runtime / netapi / test / net_test.c
1 /******************************************
2  * File: net_test.c
3  * Purpose: test app for netapi
4  **************************************************************
5  * FILE:  net_test.c
6  * 
7  * DESCRIPTION:  netapi user space transport
8  *               library  test application
9  * 
10  * REVISION HISTORY:  rev 0.0.1 
11  *
12  *  Copyright (c) Texas Instruments Incorporated 2010-2011
13  * 
14  *  Redistribution and use in source and binary forms, with or without 
15  *  modification, are permitted provided that the following conditions 
16  *  are met:
17  *
18  *    Redistributions of source code must retain the above copyright 
19  *    notice, this list of conditions and the following disclaimer.
20  *
21  *    Redistributions in binary form must reproduce the above copyright
22  *    notice, this list of conditions and the following disclaimer in the 
23  *    documentation and/or other materials provided with the   
24  *    distribution.
25  *
26  *    Neither the name of Texas Instruments Incorporated nor the names of
27  *    its contributors may be used to endorse or promote products derived
28  *    from this software without specific prior written permission.
29  *
30  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
31  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
32  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
33  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
34  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
35  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
36  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
37  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
38  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
39  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
40  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
42  *****************************************/
43 #define NET_TEST_ENABLE_SIDE_BAND_LOW_LEVEL_API
44 #ifdef NET_TEST_ENABLE_SIDE_BAND_LOW_LEVEL_API
45 #define NWAL_ENABLE_SA
46 #endif
48 #include <stdio.h>
49 #include <stdlib.h>
50 #include <unistd.h>
51 #include <string.h>
54 #include "trie.h"
55 #include "string.h"
56 #include "netapi.h"
57 #include "pktio.h"
58 #include <sys/resource.h>
59 #include "net_test.h"
60 #include <ti/drv/sa/salld.h>
61 //#define EXPERIMENTAL
62 #ifdef EXPERIMENTAL
63 #include "router.c"
64 Trie * our_router;
69 OUR_ROUTE_T routes[MAX_ROUTES]=
70 {
71 {0,{0xD4,0xbe,0xd9,0x00,0xd3,0x7e, 0x00,0x01,0x02,0x03,0x14,0x02,0x08,0x00},0},
72 {0,{0x00,0x00,0x0,0x00,0x0,0x0, 0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00},0},
73 {0,{0xD4,0xbe,0xd9,0x00,0xd3,0x7e, 0x00,0x01,0x02,0x03,0x14,0x02,0x08,0x00},0},
74 {0,{0x00,0x15,0x60,0xa1,0xf7,0xbe, 0x00,0x01,0x02,0x03,0x04,0x05,0x08,0x00},0},
75 {0,{0xd4,0xbe,0xd9,0x00,0xd3,0x7e, 0x00,0x01,0x02,0x03,0x04,0x05,0x08,0x00},0}};
77 unsigned int ip[MAX_ROUTES]={BE(0x0a0100c8),BE(0x0a00000a),BE(0x0a02000a),BE(0xc0a8010a),BE(0x9eda6719)};
79 #endif
80 //#define TEST_TIMERS
82 /*************debug********************/
83 void dump_descr(unsigned long *p, int n)
84 {
85    printf("--------dump of descriptor %d %x\n", n, (int) p);
86    printf("> %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]);
87    printf("> %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]);
88    printf("-----------------------------\n");
89 }
90 void dump_header(unsigned long *p, int n, int a, int r)
91 {
92    printf("--------dump of header %d %x appID=%x flag1=%x\n", n, (int) p,a,r);
93    printf("> %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]);
94    printf("> %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]);
95    printf("> %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]);
96    printf("> %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]);
97    printf("-----------------------------\n");
98 }
100 /*****************************************/
103 //************for multi pkt burst  xfer test in loopback mode
104 #define TX_BURST 700 
105 int pktloopback=TUNE_NETAPI_NWAL_ENABLE_PASS_LOOPBACK;
106 nwalTxPSCmdInfo_t   flowPSCmdInfo;
107 nwal_RetValue       nwalRetVal;
109 /* Local Per Process default resourcese maintained at NWAL */
110 nwalLocCxtInfo_t    nwalLocCxt;
112 //this device: 10.0.0.100, mac 0x,01,02,03,04,05  and .. 0x6
114 //test packet, setup for loopback (so dest is ourself)
115 static uint8_t testPkt[] = {
117   /* MAC header */
118   0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
119   0x00, 0xe0, 0xa6, 0x66, 0x57, 0x04,
120   0x08, 0x00,
122   /* IP header */
123   0x45, 0x00,
124   0x00, 0x6c,  /* Length (including this header) */
125   0x00, 0x00, 0x00, 0x00, 0x05, 0x11,
126   0x00, 0x00,  /* Header checksum */
127   0x0a, 0x00, 0x00, 0x0a, 0x0a, 0x00, 0x00, 0x64,
129   /* UDP header */
130   0x12, 0x34, 0x05, 0x55,
131   0x00, 0x58,  /* Length, including this header */
132   0x00, 0x00,  /* Header checksum */
134  /* Payload */
135   0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
136   0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41,
137   0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
138   0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51,
139   0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
140   0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61,
141   0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
142   0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71,
143   0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
144   0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81
146 };
148 char    input_file_name[] = "net_test_config.txt";
149 #define MAX_LINE_LENGTH 40
151 #define TEST_PAYLOAD_LEN            80
153 #define TEST_PKT_IP_OFFSET_BYTES        14
154 #define TEST_PKT_UDP_OFFSET_BYTES       34
155 #define TEST_PKT_PLOAD_OFFSET_BYTES     42
156 #define TEST_PKT_UDP_HDR_LEN            8
157 /* Offsets to length fields */
158 #define TEST_PKT_OFFSET_IP_LEN      16
159 #define TEST_PKT_OFFSET_UDP_LEN     38
161 #define TEST_PKT_LEN                122
163 /* The pseudo header checksum of the packet except for the 16 bit length */
164 #define TEST_PKT_PSEUDO_HDR_CHKSUM_SANS_LEN  0x0FFC
166 void example_fast_poll( PKTIO_HANDLE_T * p_pktio, int max_pkts);
167 void example_fast_pushpop(Pktlib_HeapHandle p_heap, int ntrials);
169 void recv_cb_router(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
170                          PKTIO_METADATA_T meta[], int n_pkts,
171                          uint64_t ts );
174 //#include "arpa/inet.h"
175 long htonl(long x)
177         long temp = (x&0xff000000)>>24 | (x&0xff0000)>>8 | (x&0xff00)<<8 |  (x&0xff)<<24 ;
178         return temp;
181 /********************************************************************
182  *  FUNCTION PURPOSE: Ones complement addition utility
183  ********************************************************************
184  ********************************************************************/
185 uint16_t test_utilOnesComplementAdd (uint16_t v1, uint16_t v2)
187   uint32_t result;
189   result = (uint32_t)v1 + (uint32_t)v2;
190   result = (result >> 16) + (result & 0xffff);
191   result = (result >> 16) + (result & 0xffff);
193   return ((uint16_t)result);
196 /********************************************************************
197  *  FUNCTION PURPOSE: Ones complement checksum utility
198  ********************************************************************
199  ********************************************************************/
200  uint16_t test_utilOnesCompChkSum (uint8_t *p, uint32_t nwords)
202   uint16_t chksum = 0;
203   uint16_t v;
204   uint32_t i;
205   uint32_t j;
207   for (i = j = 0; i < nwords; i++, j+=2)  {
208     v = (p[j] << 8) | p[j+1];
209     chksum = test_utilOnesComplementAdd (chksum, v);
210   }
211   return (chksum);
212 } /* utilOnesCompChkSum */
214 /**************************************************************************************
215  * FUNCTION PURPOSE: Compute ipv4 psudo checksum
216  **************************************************************************************
217  * DESCRIPTION: Compute ipv4 psudo checksum
218  **************************************************************************************/
219 uint16_t test_utilGetIpv4PsudoChkSum (uint8_t *data, uint16_t payloadLen)
221   uint16_t psudo_chksum;
223   psudo_chksum = test_utilOnesCompChkSum (&data[12], 4);
224   psudo_chksum = test_utilOnesComplementAdd(psudo_chksum, (uint16_t) data[9]);
225   psudo_chksum = test_utilOnesComplementAdd(psudo_chksum, payloadLen);
227   return (psudo_chksum);
229 } /* utilGetIpv4PsudoChkSum */
233 /* net test default configuration */
234 netTestConfig_t config =
236     {0x00,0x01,0x02,0x03,0x05,0x05},
237     {0x00,0x01,0x02,0x03,0x05,0x06},
238     {10, 0, 0, 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
239     {10, 0, 1, 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
240     {10, 0, 2, 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
241     {192,168 , 1, 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
242     {192,168 , 1, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
243     IPSEC_MODE_RX_SIDEBAND,
244     IPSEC_MODE_TX_SIDEBAND,
245     0
246 };
248 #if 1  //goes with real tx (to laptop) 
249 unsigned char real_mac_header[]={0xd4,0xbe,0xd9,0x00,0xd3,0x7e,
250                       0x00,0x01,0x02,0x03,0x04,0x05,
251                       0x08,0x00};
252 unsigned char real_ip_addr[]={0xa,0x00,0x00,0x64,0xa,0x0,0x0,0xa};
253 #endif
255 #if 0  //goes with loopback
256 unsigned char mac_header[]={0x00,0x01,0x02,0x03,0x04,0x05, 
257                       0x00,0x11,0x22,0x33,0x44,0x55,
258                       0x08,0x00};
259 #endif
260 #define NE 65536 
261 HEAD_T *nat;
263 #define NP 5000
264 int n_pkt = NP;
265 STATS_T stats;
267 Trie * P_trie;
268 Trie *p_trie_sa;
269 HEAD_T pkts[NP];
270 #define PERSLOW  10  //% of pkts that will not be fastpath'd 
271 int perslow= PERSLOW;
273 /*******************************************
274  *************NETAPI OBJECTS***************
275  *****************************************/
276 static NETAPI_CFG_T our_netapi_default_cfg=
278 TUNE_NETAPI_PERM_MEM_SZ,
279 128,  //start of packet offset for hw to place data on rx for default flow
280 TUNE_NETAPI_QM_CONFIG_MAX_DESC_NUM, //max number of descriptors in system
281 TUNE_NETAPI_NUM_GLOBAL_DESC,        //total we will use
282 TUNE_NETAPI_DEFAULT_NUM_BUFFERS,   //#descriptors+buffers in default heap
283 64, //#descriptors w/o buffers in default heap
284 TUNE_NETAPI_DEFAULT_BUFFER_SIZE+128+128,  //size of buffers in default heap
285 128   ,  //tail room
286 256      //extra room 
287 };
289 Pktlib_HeapHandle OurHeap;
290 Pktlib_HeapHandle specialSmall;
291 Pktlib_HeapHandle specialLarge;
293 PKTIO_HANDLE_T *our_chan;
294 PKTIO_HANDLE_T *netcp_rx_chan;
295 PKTIO_HANDLE_T *netcp_rx_chan2;
296 PKTIO_HANDLE_T *netcp_tx_chan;
297 PKTIO_HANDLE_T *netcp_sb_tx_chan;
298 PKTIO_HANDLE_T *netcp_sb_rx_chan;
299 PKTIO_CFG_T our_chan_cfg={PKTIO_RW, PKTIO_LOCAL, PKTIO_Q_ANY, 8};
300 PKTIO_CFG_T netcp_rx_cfg={PKTIO_R, PKTIO_NA, PKTIO_NA, 8};
301 PKTIO_CFG_T netcp_rx_cfg2={PKTIO_R, (PKTIO_GLOBAL|PKTIO_PKT), PKTIO_Q_ANY, 8};
302 PKTIO_CFG_T netcp_tx_cfg={PKTIO_W, PKTIO_NA, PKTIO_NA, 8};
303 PKTIO_CFG_T netcp_sb_rx_cfg={PKTIO_R, PKTIO_NA, PKTIO_NA, 8};
304 PKTIO_CFG_T netcp_sb_tx_cfg={PKTIO_W, PKTIO_NA, PKTIO_NA, 8};
306 void house(NETAPI_SCHED_HANDLE_T *s);
307 NETAPI_T netapi_handle;
308 NETAPI_SCHED_HANDLE_T * our_sched;
309 NETAPI_SCHED_CONFIG_T our_sched_cfg={
310   NETAPI_SCHED_DURATION|NETAPI_SCHED_CBV, 0, house, 5000000  //every 5000000 poll loops
311 };
312 void our_stats_cb(NETAPI_T h, paSysStats_t* pPaStats);
313 NETAPI_TIMER_GROUP_HANDLE_T ourTimerBlock; 
314 NETAPI_TIMER_T t1;
315 NETAPI_TIMER_T t2;
316 NETAPI_TIMER_T t3;
318 void our_timer_cb( NETAPI_TIMER_GROUP_HANDLE_T th,
319         int n_fired,     //# timers fired
320         NETAPI_TIMER_LIST_T fired_list,
321         uint64_t currentTime);
323 NETCP_CFG_IP_T ip_rule0;
324 NETCP_CFG_IP_T ip_rule1;
325 NETCP_CFG_CLASS_T class_0;
326 NETCP_CFG_CLASS_T class_1;
327 NETCP_CFG_CLASS_T class_2;
328 NETCP_CFG_FLOW_HANDLE_T specialFlow;
330 NETCP_CFG_CLASSIFIER_T class_0_cfg=
332    NETCP_CFG_CLASS_TYPE_L4,
333    {
334         {0,0, NWAL_APP_PLOAD_PROTO_UDP, {2500}}
335    }
336 };
338 NETCP_CFG_CLASSIFIER_T class_1_cfg=
340    NETCP_CFG_CLASS_TYPE_L4,
341    {
342         {0,0, NWAL_APP_PLOAD_PROTO_UDP, {2502}}
343    }
344 };
346 NETCP_CFG_ROUTE_T  class2_route=
348 NULL, NULL  //* to be filled in
349 };
350 NETCP_CFG_CLASSIFIER_T class_2_cfg=  
352    NETCP_CFG_CLASS_TYPE_L3_L4,
353    {
354         {0,  4 ,0/*fill in below*/ , NULL, NULL,          //L2/L3
355            NWAL_APP_PLOAD_PROTO_UDP, {2504}}   //L4
356    }
357 };
359 PKTIO_CONTROL_T zap_channel_control={PKTIO_CLEAR, NULL};
361 /* security objects. (for loopback mode) */
362 netTestSA_t sa_info[4];
363 int netapi_algorithm_set = 0;
364 int netapi_sec_sa_mode = 2;
365 /* tmannan-end */
366 //NETCP_CFG_SA_T rx_tunnel;
367 //NETCP_CFG_SA_T tx_tunnel;
368 NETCP_CFG_IPSEC_POLICY_T rx_policy[4];
369 //void * rx_data_mode_handle;
370 //void * tx_data_mode_handle;
371 //void * rx_inflow_mode_handle;
372 //void * tx_inflow_mode_handle;
373 /* rx */
376 NETAPI_SEC_SA_INFO_T rx_sa [4] = {
378     NWAL_SA_DIR_INBOUND,
379     0x11111111,  //spi
380     nwal_IpSecProtoESP, //ESP mode
381     nwal_SA_MODE_TUNNEL,  //tunnel mode
382     nwal_IPV4, //v4
383     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (them) -> set below */
384     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (us)-> set below*/
385     64,/* replayWindow */
386     NWAL_SA_AALG_HMAC_SHA1,
387     NWAL_SA_EALG_AES_CBC,
388     0,0  //na
389 },
391     NWAL_SA_DIR_INBOUND,
392     0x22222222,  //spi
393     nwal_IpSecProtoESP, //ESP mode
394     nwal_SA_MODE_TUNNEL,  //tunnel mode
395     nwal_IPV4, //v4
396     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (them) -> set below */
397     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (us)-> set below*/
398     64,/* replayWindow */
399     NWAL_SA_AALG_HMAC_SHA2_256,
400     NWAL_SA_EALG_AES_CTR,
401     0,0  //na
402 },
404     NWAL_SA_DIR_INBOUND,
405     0x33333333,  //spi
406     nwal_IpSecProtoESP, //ESP mode
407     nwal_SA_MODE_TUNNEL,  //tunnel mode
408     nwal_IPV4, //v4
409     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (them) -> set below */
410     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (us)-> set below*/
411     64,/* replayWindow */
412     NWAL_SA_AALG_HMAC_SHA2_256,
413     NWAL_SA_EALG_3DES_CBC,
414     0,0  //na
415 },
417     NWAL_SA_DIR_INBOUND,
418     0x44444444,  //spi
419     nwal_IpSecProtoESP, //ESP mode
420     nwal_SA_MODE_TUNNEL,  //tunnel mode
421     nwal_IPV4, //v4
422     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (them) -> set below */
423     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (us)-> set below*/
424     64,/* replayWindow */
425     NWAL_SA_AALG_HMAC_MD5,
426     NWAL_SA_EALG_NULL,
427     0,0  //na
429 };
431 /*tx */
432 NETAPI_SEC_SA_INFO_T tx_sa[4]= {
434     NWAL_SA_DIR_OUTBOUND,
435     0x11111111,  //spi
436     nwal_IpSecProtoESP, //ESP mode
437     nwal_SA_MODE_TUNNEL,  //tunnel mode
438     nwal_IPV4, //v4
439     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (us) -> set below */
440     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (them) -> set below*/
441     64, /* NA replayWindow */
442     NWAL_SA_AALG_HMAC_SHA1,
443     NWAL_SA_EALG_AES_CBC,
444     0,0  //seq no
445 },
446     {
447     NWAL_SA_DIR_OUTBOUND,
448     0x22222222,  //spi
449     nwal_IpSecProtoESP, //ESP mode
450     nwal_SA_MODE_TUNNEL,  //tunnel mode
451     nwal_IPV4, //v4
452     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (us) -> set below */
453     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (them) -> set below*/
454     64, /* NA replayWindow */
455     NWAL_SA_AALG_HMAC_SHA2_256,
456     NWAL_SA_EALG_AES_CTR,
457     0,0  //seq no
458 },
460     NWAL_SA_DIR_OUTBOUND,
461     0x33333333,  //spi
462     nwal_IpSecProtoESP, //ESP mode
463     nwal_SA_MODE_TUNNEL,  //tunnel mode
464     nwal_IPV4, //v4
465     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (us) -> set below */
466     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (them) -> set below*/
467     64, /* NA replayWindow */
468     NWAL_SA_AALG_HMAC_SHA2_256,
469     NWAL_SA_EALG_3DES_CBC,
470     0,0  //seq no
471 },
473     NWAL_SA_DIR_OUTBOUND,
474     0x44444444,  //spi
475     nwal_IpSecProtoESP, //ESP mode
476     nwal_SA_MODE_TUNNEL,  //tunnel mode
477     nwal_IPV4, //v4
478     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (us) -> set below */
479     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (them) -> set below*/
480     64, /* NA replayWindow */
481     NWAL_SA_AALG_HMAC_MD5,
482     NWAL_SA_EALG_NULL,
483     0,0  //seq no
485 };
487 static nwalSecKeyParams_t ourTXKeyParams[4] ={
489     16, /* encKeySize: CTR 16 bytes Encryption Key and 4 bytes Salt : 24 bytes:NWAL_SA_EALG_3DES_CBC and 0 bytes Salt*/
490     20, /* macKeySize: 16 bytes NWAL_SA_AALG_HMAC_SHA1 */
491     NULL, //set below
492     NULL, //set below
493 },
495     20, /* encKeySize: CTR 16 bytes Encryption Key and 4 bytes Salt : 24 bytes:NWAL_SA_EALG_AES_CTR and 0 bytes Salt*/
496     32, /* macKeySize: 16 bytes NWAL_SA_AALG_HMAC_SHA2_256 */
497     NULL, //set below
498     NULL, //set below
499 },
501     24, /* encKeySize: DES-CBC: 24 bytes:NWAL_SA_EALG_3DES_CBC and 0 bytes Salt*/
502     32, /* macKeySize: 16 bytes NWAL_SA_AALG_HMAC_SHA2_256 */
503     NULL, //set below
504     NULL, //set below
505 },
507     0, /* NULL*/
508     16, /* MD5, 16 bytes */
509     NULL, //set below
510     NULL, //set below
512 };
514 /* these keys are for aes-ctr and hmac sha2_256 */
515 static nwalSecKeyParams_t ourRXKeyParams[4] ={
517     16, /* encKeySize: CTR 16 bytes Encryption Key and 4 bytes Salt : 24 bytes:NWAL_SA_EALG_3DES_CBC and 0 bytes Salt*/
518     20, /* macKeySize: 16 bytes NWAL_SA_AALG_HMAC_SHA1 */
519     NULL, //set below
520     NULL, //set below
521 },
523     20, /* encKeySize: CTR 16 bytes Encryption Key and 4 bytes Salt : 24 bytes:NWAL_SA_EALG_AES_CTR and 0 bytes Salt*/
524     32, /* macKeySize: 16 bytes NWAL_SA_AALG_HMAC_SHA2_256 */
525     NULL, //set below
526     NULL, //set below
527 },
529     24, /* encKeySize: DES-CBC: 24 bytes:NWAL_SA_EALG_3DES_CBC and 0 bytes Salt*/
530     32, /* macKeySize: 16 bytes NWAL_SA_AALG_HMAC_SHA2_256 */
531     NULL, //set below
532     NULL, //set below
533 },
535     0, /* NWAL_SA_EALG_NULL*/
536     16, /* NWAL_SA_AALG_HMAC_MD5, 16 bytes */
537     NULL, //set below
538     NULL, //set below
540 };
543 static uint8_t ourAuthKey[36] =
544         {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
545          0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
546          0x20, 0x21, 0x22, 0x23 };
549 static uint8_t ourEncrKey[36] = 
550         {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF,
551          0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF,
552          0x30, 0x31, 0x32, 0x33 }; 
555 /*************************END NETAPI OBJECTS***********************/
557 #define START_SRC_IP 0x0a00000a
558 #define DST_IP       0xc0a80001
559 #define NEW_START_SRC_IP 0x9eda000a
560 #define DST_PORT 0x555 
561 #define START_SRC_PORT 0x1234
562 #define NEW_START_SRC_PORT 100
563 void update_header(HEAD_T * p_head, int len)
565    unsigned char *p = (unsigned char *) &p_head->udp[1];
566    len -= (20+14);
567    /* update ip checksum */
568    /* update udp checksum */
569    /* update length */
570    *p= (len&0xff00)>>8;
571    *(p+1) = len&0xff;
574 #if 0
575 void gen_pkts(int np)
577 int i;
578 int ip = START_SRC_IP &0xff;
579 int port= START_SRC_PORT;
580 //HEAD_T temp={{0x25000200,0xdead0000,0x80110000,START_SRC_IP,DST_IP},
581 //             {START_SRC_PORT<<16|DST_PORT,0x01ec<<16|0x0000}};
582 HEAD_T temp;
583 memcpy(&temp,&testPkt[0],sizeof(HEAD_T));
585 for(i=0;(i<np) && (i<NP);i++)
586   {
587        memcpy(&pkts[i],&temp,sizeof(temp));
588        update_header(&pkts[i],512);      /* update checksums etc */
589        /* change template for new pkt */
590        ip+=1;
591        if(ip>254) {(ip=START_SRC_IP&0xff); port+=1; }
592        temp.ip[3] = htonl((START_SRC_IP&0xffffff00)| ip);
593        temp.udp[0] = htonl( (temp.udp[0]&0xffff0000)| port);
594        temp.udp[1] = htonl(temp.udp[1]);
595      
596   }
597   n_pkt=np;
599 #endif
601 void build_table(Trie * p_trie)
603 int i;
604 int sport=NEW_START_SRC_PORT; 
605 HEAD_T temp,temp2;
606 KEY_T key;
608 memcpy(&temp,&testPkt[14],sizeof(temp));
610  //insert entry into trie
611 key.src_ip = temp.ip[3];
612 key.dst_ip = temp.ip[4];
613 key.src_port= (temp.udp[0]&0xffff0000)>>16;
614 key.dst_port= (temp.udp[0]&0x0000ffff);
615 trie_insert(p_trie,(char *)&key,sizeof(key), (void *) &nat[0]); //asociate with nat entry 0
617 //build nat table
618 for(i=0;i<100;i++)
620    memcpy(&temp2,&testPkt[14],sizeof(temp));
621    temp2.udp[0] = (temp2.udp[0] & 0xffff0000) |  sport;
622    memcpy(&nat[i], &temp2, sizeof(temp2));
623    sport+= 1;
627 //===========stub transmitter==================
628 void send_pkt(Ti_Pkt *pkt, int len)
630 //just free pkt.  Don't send
631 Pktlib_freePacket((Ti_Pkt*)pkt);
632         return;
635 //==========stub slow path============
636 void slow_path(Ti_Pkt *pkt, int len)
638 // debug: check descriptor for validity by verifying that desciptor link field is null as expected\n");
639          {Ti_Pkt * k= Pktlib_getNextPacket(pkt); if(k != 0) {printf(" slowpath, nexpkt != NULL");}}
640 //just free pkt
641 Pktlib_freePacket((Ti_Pkt*)pkt);
642         return;
644 /* check header */
645 struct LastPktInfo
647 int iface;
648 int ipcsum;
649 int l4csum;
650 } ;
651 static struct LastPktInfo lpInfo;
653 int check_header(HEAD_T * p_head, PKTIO_METADATA_T * p_meta)
655 if (NWAL_RX_FLAG1_META_DATA_VALID & p_meta->u.rx_meta->rxFlag1)
657 lpInfo.iface = ((unsigned int)p_meta->u.rx_meta->appId) &0xff; //last byte is interface num
658 lpInfo.ipcsum =(p_meta->u.rx_meta->rxFlag1 & NWAL_RX_FLAG1_IPV4_CHKSUM_VERIFY_MASK )== NWAL_RX_FLAG1_IPV4_CHKSUM_VERIFY_ACK ? 1 : 0;
659 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; 
660 if ((unsigned int)p_meta->u.rx_meta->appId & NETAPI_NETCP_MATCH_IPSEC)
662    stats.sec_rx++;
664 if ((unsigned int)p_meta->u.rx_meta->appId & NETAPI_NETCP_MATCH_IPSEC_POLICY)
666    stats.secp_rx++;
669 if ((unsigned int)p_meta->u.rx_meta->appId & NETAPI_NETCP_MATCH_CLASS)
671   int c= ((unsigned int)p_meta->u.rx_meta->appId >>8)&0xffff;
672   if (c==0)  stats.n_class0_rx +=1;
673   else if (c==1) stats.n_class1_rx +=1;
674   else if (c==2) stats.n_class2_rx +=1;
675   else printf("**NET_TEST RX -unknown class: %x\n",  p_meta->u.rx_meta->appId);
679  return 1;
682 #define PKT_LEN 1400
683 void test_alloc_free(int n)
685 int i;
686 Ti_Pkt * b;
688 for(i=0;i<n;i++)
690   b=Pktlib_allocPacket(OurHeap,PKT_LEN);
691   Pktlib_freePacket(b);
695 //measurement test points
696 unsigned int vv1;
697 unsigned int vv2;
698 unsigned int vv3;
699 unsigned int vv4;
700 unsigned int vv5;
701 unsigned int vv6;
702 //these are updated by pktio.
703 #ifdef PKTIO_GET_BENCHMARK
704 extern unsigned int vv7p;
705 extern unsigned int vv8p;
706 extern unsigned int vv9p;
707 extern unsigned int vv10p;
708 extern unsigned int vv11p;
709 extern unsigned int vv12p;
711 extern unsigned int vv13p;  //rcv path
712 extern unsigned int vv14p;
713 extern unsigned int vv15p;
714 #endif
716 unsigned int vv11;
718 extern unsigned int nwal_prof1,nwal_prof2,nwal_prof3,nwal_prof4,nwal_prof5,nwal_prof6;
720 //#define REASSEMBLE_BENCH
721 #ifdef REASSEMBLE_BENCH
722 #include <ti/drv/pa/example/reassemLib/reassemLib.h>
723 /*--------------reassembly benchmark--------------------------------*/
724 void our_reassemble_bench(int nfrags)
726 paIPReassemblyConfig_t Config={5,128,10000 };
727 int i,j;
728 int len;
729 Ti_Pkt tip;
730 char *buffer;
731 unsigned long v1;
732 unsigned long v2;
733 unsigned long sum1=0;
734 unsigned long sum2=0;
735 paEx_reassemLibInit(&Config);
736 for(j=0;j<200/nfrags;j++)
738   for(i=0;i<nfrags;i++)
739   {
740     short temp;
741     tip=Pktlib_allocPacket(OurHeap,PKT_LEN);
742     Pktlib_getDataBuffer(tip,(uint8_t**)&buffer,&len);
743     memcpy(&buffer[0],&testPkt[14],20); //IP header
744     if (i < (nfrags-1)) buffer[6] = 0x20;
745     temp = i*40; 
746     buffer[6]|= (temp&0x1f00)>>8;
747     buffer[7]= (temp&0xff);
748     temp = 20+40*8; 
749     buffer[2]= (temp&0xff00)>>8;
750     buffer[3]= (temp&0xff);
751     Pktlib_setPacketLen(tip, temp);
752     v1= netapi_timing_stop();
753     paEx_reassemLibProc(tip, 0xffff);
754     v2= netapi_timing_stop();
755     sum1+= v2-v1;
756   }
757   sum2 += v2-v1;
759 printf("reasssembly test:  %d trials, %d frags/pkt  %d cycles/frag %d cycles/last frag\n",j,nfrags, sum1/(j*nfrags), sum2/(j));
761 #endif
763 /*--------------basic pktio send/recv benchmark----------------------*/
764 unsigned int timings[10];
765 void our_pktio_bench(int ntrials)
767 int i;
768 #define NBATCH 8
769 Ti_Pkt tip;
770 unsigned char * pData;
771 int len;
772 int n;
773 int err;
774 int sum =0;
776    Osal_cache_op_measure_reset();
777    for(i=0;i<10;i++) timings[i]=0;
778    printf("calibration loop .. ");
779    for(i=0;i<1000;i++)
780    {
781    vv1= netapi_timing_stop();
782    vv2= netapi_timing_stop();
783    sum+=(vv2-vv1);
784    }
785    printf(" accuracy = +- %d cycles\n", sum/1000);
786    sleep(1);
787   
788 PKTIO_METADATA_T meta[10]={0};
789 //send single, recv single
790 for(i=0;i<ntrials;i++)
792    vv1= netapi_timing_stop();
793    tip=Pktlib_allocPacket(OurHeap,PKT_LEN);
794    vv2= netapi_timing_stop();
795    Pktlib_getDataBuffer(tip,&pData,&len);
796    vv3= netapi_timing_stop();
797    pktio_send(our_chan,tip,&meta[0],&err);
798    vv4= netapi_timing_stop();
799    n=pktio_poll(our_chan,NULL , &err);
800    vv5=   netapi_timing_stop();
801    timings[0]+=(vv6-vv4);
802    timings[1]+=(vv5-vv4);
803    timings[3]+=(vv4-vv3); 
804    timings[5]+=(vv3-vv1);
805    timings[8]+=(vv11-vv6);
807 #ifdef PKTIO_GET_BENCHMARK
808    timings[2]+=(vv7p-vv4);
809    timings[4]+=(vv8p-vv3);
810    timings[6]+=(vv9p-vv8p);
811    timings[7]+=(vv10p-vv7p);
812 #endif
815 #ifdef PKTIO_GET_BENCHMARK
816    printf("pktio bench. rx=%d (wcb%d) (toqm%d) tx=%d (toqm%d) alloc=%d qpush=%d qpop=%d free=%d\n", timings[0]/ntrials,
817            timings[1]/ntrials, timings[2]/ntrials,timings[3]/ntrials, timings[4]/ntrials,timings[5]/ntrials,
818            timings[6]/ntrials,timings[7]/ntrials, timings[8]/ntrials );
819    {
820        unsigned int ccycles;
821        int n_c_ops;
822        ccycles =Osal_cache_op_measure(&n_c_ops);
823        printf("n_c_ops=%d cache_op_time=%d (total) = %d (pp)\n", n_c_ops, ccycles,  n_c_ops? (ccycles/(n_c_ops)) : 0);
824    }
825 #endif
828 /*-----------test driver: gen an input pkt------- */
829 //char buffer[sizeof(HEAD_T)+PKT_LEN];
830 Ti_Pkt * get_pkt(int n, unsigned int *p_len, Pktlib_HeapHandle heap2use, int size, unsigned char * buf2cpy, int copy_size)
832    int ind;
833    long long temp;
834    Ti_Pkt * b;
835    char * buffer;
836    unsigned int len;
838   if (pktloopback==0)
839   {
840         if (n>=TX_BURST) return NULL;   //just gen pkts to warm swtich, so that it knows
841                                 //our mac is valid
842   }  
843   b=Pktlib_allocPacket(heap2use,size);
844   if (!b) 
845     {printf("net_test: get_pkt() heap empty!! %d pkts gen'd %d \n", n); return NULL;};
847     //debug - way to validate descriptor
848     {Ti_Pkt* k= Pktlib_getNextPacket(b); 
849          if(k != 0) {printf(" genpkt, nexpkt != NULL");}}
852    //get pointer to buffer area of packet
853    Pktlib_getDataBuffer(b,(uint8_t**)&buffer,&len);
854    if (!buffer) 
855     {printf("net_test: get_pkt() heap returned empty buffer %d \n", n); return NULL;};
857 #if 0 
858 if (pktloopback==0)
860    temp = (long long) rand();
861    temp *= PKT_LEN;
862    temp /= RAND_MAX;
863    temp +=2;
864    *p_len = (int) temp; 
865    *p_len = *p_len &0xfffffffe;
866    temp = (long long) rand();
867    temp *= n_pkt;
868    temp /= RAND_MAX;
869    ind = (int) temp;
870    update_header(&pkts[ind],*p_len);
871    //printf("get pkt:%d %d ind=%d len=%d\n",RAND_MAX, rand(),ind, *p_len);
872     memcpy(&buffer[0], &mac_header[0],14);
873     memcpy(&buffer[14],(char*)&pkts[ind],sizeof(HEAD_T)); 
875 else
876 #endif
878    //copy test packet into buffer
880     memcpy(&buffer[0], buf2cpy, copy_size);
881     *p_len = copy_size;
883     return b; 
886 static int eof=0;
887 /*--------------------------------------------------------------
888  *----------utility to flip a packet and send 
889  *--------------------back to source----------------------------
890  *                   flag=1 => ipsec
891  *--------------------------------------------------------------*/
892 void flip_and_send_pkt(Ti_Pkt *tip,  unsigned char * p_pkt, int len, int flag)
894 unsigned char mac_temp[6];
895 unsigned char ip_temp[4];
896 unsigned char new_dest_port[2]={0x75,0x30};  // 30000
897 uint16_t blah; 
898 uint16_t i=1;   /* for testing only */
900 uint8_t *p_spi; 
901 netTestSA_t * p_sa_info;
902 uint8_t p_iv[16];
903 Cppi_HostDesc*          pPloadDesc;
905 Pktlib_setPacketLen(tip,len);
906 //mac
907 memcpy(&mac_temp,&p_pkt[0],6);
908 memcpy(&p_pkt[0],&p_pkt[6],6);
909 memcpy(&p_pkt[6],&mac_temp,6);
910 //memcpy(&p_pkt[0],real_mac_header,6); //for testing to wireshark pc
912 //ip  (outer in case of ipsec)
913 memcpy(&ip_temp, &p_pkt[14+12],4);
914 memcpy(&p_pkt[14+12],&p_pkt[14+12+4],4);
915 memcpy(&p_pkt[14+12+4],&ip_temp,4);
917 //outer checksum to 0
918 if (!flag) memset(&p_pkt[14+10],0,2);
923 //inner ip &udp for ipsec
924 if (flag) 
926     p_spi = &(p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN]);
927     p_sa_info = (netTestSA_t *) trie_lookup(p_trie_sa, (char *)p_spi ,4);
928     if (p_sa_info == NULL)
929     {
930         printf("flip_and_send_pkt(): trie_lookup() failed\n");
931         return;
932     }
933     //just drop non-udp packet
934     if (p_pkt[p_sa_info->tx_payload_info.encOffset+9]!=0x11)
935   
936     {
937         stats.n_new+=1;Pktlib_freePacket(tip); return;
938     }
940 memcpy(&ip_temp, &p_pkt[p_sa_info->tx_payload_info.encOffset+12],4);
941 memcpy(&p_pkt[p_sa_info->tx_payload_info.encOffset+12],&p_pkt[p_sa_info->tx_payload_info.encOffset+12+4],4);
942 memcpy(&p_pkt[p_sa_info->tx_payload_info.encOffset+12+4],&ip_temp,4);
944 //udp
945 memcpy(&p_pkt[p_sa_info->tx_payload_info.encOffset+20+2],&new_dest_port[0],2);
946 memset(&p_pkt[p_sa_info->tx_payload_info.encOffset+20+6],0,2); //checksum
951 if (config.ipsec_mode_tx == IPSEC_MODE_TX_SIDEBAND)
953     //inner ip checksum : leave alone
954 #if 0
955     blah=test_utilOnesCompChkSum (&p_pkt[14+20+8+16], 10);
956     p_pkt[14+20+8+16+10]= (blah&0xff00)>>8;
957     p_pkt[14+20+8+16+11]= blah&0xff;
958 #endif
960     //tbd udp checksum (leave at 0)
962     //outer ip, set to 0 (we will compute on way out
963     memset(&p_pkt[14+10],0,2);
965 else
967 //#else //inflow, don't touch outer , clear inner 
968 //DALmemset(&p_pkt[14+20+8+16+10],0,2); //inner checksum, we will compute on way out
969 //outer ip checksum : leave alone
971 #if 0
972 blah = test_utilOnesCompChkSum (&p_pkt[14], 10);
973 p_pkt[14+10]= (blah&0xff00)>>8;
974 p_pkt[14+11]= blah&0xff;
975 #endif
979 else
981 memset(&p_pkt[14+20+6],0,2);//0 udp checksum (we will compute on way out
982 memcpy(&p_pkt[14+20+2],&new_dest_port[0],2);
985 //IPSEC case, 
986 if (flag)
988         if (config.ipsec_mode_tx == IPSEC_MODE_TX_SIDEBAND)
989  //send to crypto for encryption
990 //12 byte auth tag
991         {
992            PKTIO_METADATA_T meta = {PKTIO_META_SB_TX,{0},0};
993            int err;
994            nwalDmTxPayloadInfo_t meta_tx={0};
995            meta.sa_handle=p_sa_info->tx_data_mode_handle;  //use TX SA context
997 #if 0
999            meta_tx.encOffset =p_sa_info->tx_payload_info.encOffset;
1000            
1001            meta_tx.authOffset =netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN;
1003            //meta_tx.encSize=len - 14- 20-8-16-12;
1004            meta_tx.encSize = len - p_sa_info->tx_payload_info.encOffset -netTest_ICV_LEN;
1005            
1006            //meta_tx.authSize= len -14-20-12;
1007            meta_tx.authSize = len - meta_tx.authOffset - netTest_ICV_LEN;
1008            //meta_tx.pEncIV= &p_pkt[14+20+8];  //just use same IV..
1009 #endif
1010             memcpy(&meta_tx, &(p_sa_info->tx_payload_info), sizeof(nwalDmTxPayloadInfo_t));
1012           
1013            meta_tx.encSize = len - p_sa_info->tx_payload_info.encOffset -netTest_ICV_LEN;
1014            meta_tx.authSize = len - meta_tx.authOffset - netTest_ICV_LEN;
1016 #if 0
1017             printf("flip_and_send_pkt(): encOffset %d\n", meta_tx.encOffset);
1018             printf("flip_and_send_pkt():authOffset %d\n", meta_tx.authOffset);
1019             printf("flip_and_send_pkt(): encSize %d\n", meta_tx.encSize);
1020             printf("flip_and_send_pkt(): authSize %d\n", meta_tx.authSize);
1021 #endif
1023         if (p_sa_info->cipherMode ==  NWAL_SA_EALG_AES_CTR)
1024         {
1025            memcpy(&p_iv[0], &ourEncrKey[16], 4);
1026            memcpy(&p_iv[4], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
1027             p_iv[12] = 0;
1028             p_iv[13] = 0;
1029             p_iv[14] = 0;
1030             p_iv[15] = 1;
1031            meta_tx.pEncIV = &p_iv[0];
1032          }
1033         else if (p_sa_info->cipherMode ==  NWAL_SA_EALG_NULL)
1034         {
1035             meta_tx.pEncIV = NULL;
1036         }
1037         else
1038         {
1039             meta_tx.pEncIV = &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN ];
1040         }
1041            meta_tx.pAuthIV=NULL;
1042            meta_tx.aadSize=0;
1043            meta_tx.pAad=NULL;
1044            /* post it to netcp sb tx channel*/
1045            meta_tx.appCtxId = (nwal_AppId)netapi_timing_start();
1046            meta.u.tx_sb_meta=&meta_tx;
1048 #ifdef NET_TEST_ENABLE_SIDE_BAND_LOW_LEVEL_API
1049            /* Use the command label which was cached during create time
1050             * Update the Queue to receive output packet from SA to the local 
1051             * core Queue. Below information can be saved by application in 
1052             * per process context to avoid API overhead per packet
1053             * Application can use below rxSbSaQ for polling packets back from
1054             * SA
1055             */
1056            nwalRetVal =  
1057            nwal_getLocCxtInfo(PKTIO_GET_NWAL_INSTANCE(netcp_sb_tx_chan),
1058                                                       &nwalLocCxt);
1059            if(nwalRetVal == nwal_OK)
1060            {
1061                 p_sa_info->tx_dmPSCmdInfo.rxSbSaQ = nwalLocCxt.rxSbSaQ;
1062            }
1063            nwal_mCmdDMUpdate(tip,
1064                               &p_sa_info->tx_dmPSCmdInfo,
1065                               meta_tx.appCtxId,
1066                               meta_tx.encOffset,
1067                               meta_tx.encSize,
1068                               meta_tx.pEncIV,
1069                               meta_tx.authOffset,
1070                               meta_tx.authSize,
1071                               meta_tx.pAuthIV,
1072                               meta_tx.aadSize,
1073                               meta_tx.pAad);
1074             pPloadDesc = Pktlib_getDescFromPacket(tip);
1075             pPloadDesc = Qmss_osalConvertDescVirtToPhy(pPloadDesc);
1076             Qmss_queuePushDescSizeRaw(p_sa_info->tx_dmPSCmdInfo.txQueue,
1077                                        pPloadDesc,
1078                                        NWAL_DESC_SIZE);
1080 #else
1081            pktio_send(netcp_sb_tx_chan,tip,&meta,&err);
1082 #endif
1083        }
1084 else
1085  {
1086   //inflow tx
1087   //send pkt directly, asking for IP and UDP checksum offloads AND IPSEC to be applied
1088            PKTIO_METADATA_T meta = {PKTIO_META_TX,{0},0};
1089            int err;
1090            nwalTxPktInfo_t meta_tx={0};
1091 #define USE_COPY
1092 #ifdef USE_COPY
1093 //debug:  see if re-using RX descriptor for TX is causing our SA lockup
1095   int new_len=0;
1096   Ti_Pkt new_tip =  get_pkt(0, &new_len, specialLarge , len+10 , &p_pkt[0]   , len);
1097   if (!new_tip)
1098   {
1099      printf("net_test> new_tip NULL\n");
1100   }
1101   else
1102   {
1103     Pktlib_setPacketLen(new_tip,new_len);
1104     Pktlib_freePacket(tip);
1105     tip=new_tip;  
1106     Pktlib_getDataBuffer(tip,(uint8_t**)&p_pkt,&new_len);  //reset p_pkt to point to new buffer as its used below
1107     Cppi_setTimeStamp (Cppi_DescType_HOST, (Cppi_Desc *) tip,stats.sec_tx); 
1108   }
1110 if (len <1500)  
1112   eof+=1;
1114 #endif
1115            meta.sa_handle=p_sa_info->tx_inflow_mode_handle; //this tells netapi that inflow crypto needs to be applied
1116            //meta_tx.txFlag1 = (NWAL_TX_FLAG1_DO_IPV4_CHKSUM|NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_DO_IPSEC_ESP_CRYPTO| NWAL_TX_FLAG1_META_DATA_VALID );
1117            meta_tx.txFlag1 = p_sa_info->tx_pkt_info.txFlag1;
1118            meta_tx.enetPort=0;
1119            //meta_tx.saOffBytes=14+20;  
1120            meta_tx.saOffBytes=  p_sa_info->tx_pkt_info.saOffBytes;
1121            meta_tx.saPayloadLen=len-14-20;   //don't include tag, mac and outer header
1122            //meta_tx.startOffset = 0;
1123            meta_tx.startOffset = p_sa_info->tx_pkt_info.startOffset;
1124            //meta_tx.ipOffBytes = 14+20+8+16;   //to inner header
1125            meta_tx.ipOffBytes =p_sa_info->tx_payload_info.encOffset; 
1126            //meta_tx.l4OffBytes = 14+20+8+16+20; //to L4
1127            meta_tx.l4OffBytes = p_sa_info->tx_pkt_info.l4OffBytes;
1128            meta_tx.l4HdrLen = p_sa_info->tx_pkt_info.l4HdrLen;
1129            meta_tx.ploadLen = (unsigned) ((p_pkt[meta_tx.l4OffBytes+4]<<8)|p_pkt[meta_tx.l4OffBytes+4+1]) -8 ;
1130            meta_tx.pseudoHdrChecksum =
1131              test_utilGetIpv4PsudoChkSum(&p_pkt[meta_tx.ipOffBytes],8+ meta_tx.ploadLen);
1133            /* post it to netcp tx channel*/
1134            meta.u.tx_meta=&meta_tx;
1135            if (stats.sec_tx<20) dump_descr((long *) tip, stats.sec_tx);
1136            pktio_send(netcp_tx_chan,tip,&meta,&err);
1137            stats.tx +=1;
1138            stats.sec_tx +=1;
1139      }
1141 else  //non ipsec send pkt directly, asking for IP and UDP checksum ofload
1143            PKTIO_METADATA_T meta2 = {PKTIO_META_TX,{0},0};
1144            int err;
1145            nwalTxPktInfo_t meta_tx2={0};
1146            meta2.sa_handle=nwal_HANDLE_INVALID;
1147            meta_tx2.txFlag1 = (NWAL_TX_FLAG1_DO_IPV4_CHKSUM|NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID );
1148            meta_tx2.startOffset = 0;
1149            meta_tx2.ipOffBytes = 14;
1150            meta_tx2.l4OffBytes = 14+20;
1151            meta_tx2.l4HdrLen = 8;
1152            meta_tx2.ploadLen = (unsigned) ((p_pkt[14+20+4]<<8)|p_pkt[14+20+4+1]) -8 ;
1153            meta_tx2.pseudoHdrChecksum =
1154              test_utilGetIpv4PsudoChkSum(&p_pkt[14],8+ meta_tx2.ploadLen);
1156            /* post it to netcp tx channel*/
1157            meta2.u.tx_meta=&meta_tx2;
1158            pktio_send(netcp_tx_chan,tip,&meta2,&err);
1159            stats.tx +=1;
1166 /***************************************
1167  benchmark receive handler
1168 ****************************************/
1169 void recv_cb_bench(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
1170                          PKTIO_METADATA_T meta[], int n_pkts,
1171                          uint64_t ts )
1173    int i;
1174    vv6=   netapi_timing_stop();
1175    for (i=0;i<n_pkts; i++) 
1176    {
1177      Pktlib_freePacket(p_recv[i]);
1178    }
1179    vv11 = netapi_timing_stop();
1182 /****************************************************************************************/
1183 /******************SB Accelerator Callback PKT RECEIVE HANDLER *************************/
1184 /******************  Handles Decrypt and Encrypt operation callbacks ******************/
1185 /******************************************************************************************/
1186 void recv_sb_cb(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
1187                          PKTIO_METADATA_T meta[], int n_pkts,
1188                          uint64_t ts )
1190 int i;
1191 int len;
1192 int p;
1193 HEAD_T * p_res;
1194 Ti_Pkt * tip;
1195 unsigned int templen;
1196 int err;
1197 KEY_T key;
1198 char * p_pkt;
1199 HEAD_T * p_head;
1200 HEAD_T temp_head;
1201 int tag_cmp=0;
1202 unsigned int hash[3];
1203 uint8_t *p_spi;
1204 netTestSA_t *p_sa_info;
1206 //nwal_AppId time;
1207 unsigned long time, delta_time;
1208  /* loop over received pkts */
1209    for(i=0;i<n_pkts;i++)
1210    {
1211         tip = p_recv[i];
1212         Pktlib_getDataBuffer(tip,(uint8_t**)&p_pkt,&templen);//ignore templen
1213         len = Pktlib_getPacketLen(tip);//real length
1216          p_spi = &(p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN]);
1217         p_sa_info = (netTestSA_t *) trie_lookup(p_trie_sa, (char *)p_spi ,4);
1218         if (p_sa_info == NULL)
1219         {
1220             printf("recv_sb_cb(): trie_lookup failed\n");
1221             continue;
1222         }
1225         //is this a decrypt (rx_tunnel) complete
1226         if ((int)meta[i].u.rx_sb_meta->appId == p_sa_info->rx_tunnel)
1227         {
1228            
1229             time = netapi_timing_start();
1230            delta_time = time -(unsigned long) meta[i].u.rx_sb_meta->appCtxId;
1231             stats.total_decrypt_time += delta_time;
1232             stats.sb_rx+=1;
1233            //copy hash out of meta data (for some reason it needs endian conversion)
1234            hash[0]= htonl( meta[i].u.rx_sb_meta->pAuthTag[0]);
1235            hash[1]= htonl( meta[i].u.rx_sb_meta->pAuthTag[1]);
1236            hash[2]= htonl( meta[i].u.rx_sb_meta->pAuthTag[2]);
1238            if(stats.sb_rx<=16)
1239            {
1240              char *tp = (char *) &hash[0];
1241              //dump_header((long*)p_pkt, stats.sb_rx, (int)meta[i].u.rx_sb_meta->appId,0);
1242 #if 0
1243              printf("tag in pkt=%x %x %x %x %x %x %x %x %x %x %x %x\n",
1244                       p_pkt[len-12],p_pkt[len-11],p_pkt[len-10],p_pkt[len-9], p_pkt[len-8],
1245                       p_pkt[len-7],p_pkt[len-6],
1246                       p_pkt[len-5],p_pkt[len-4],p_pkt[len-3],p_pkt[len-2],p_pkt[len-1]);
1247              printf("tag from SA=%x %x %x %x %x %x %x %x %x %x %x %x\n",
1248                        tp[0],tp[1],tp[2],tp[3],tp[4],tp[5],
1249                        tp[6],tp[7],tp[8],tp[9],tp[10],tp[11]);
1250 #endif
1251            }
1252            //check tag 
1253            tag_cmp = memcmp(&p_pkt[len-12],(char*) &hash[0],12); //todo, really use meta->authTagLen
1254            stats.n_auth_ok += !(tag_cmp);
1255            
1256             flip_and_send_pkt(tip, p_pkt, len,1);  //flip packet to echo back and send
1257         }
1258         //this is an encrypt (tx tunnel) complete
1259         else if((int)meta[i].u.rx_sb_meta->appId== p_sa_info->tx_tunnel )
1260         {
1261            hash[0]= htonl( meta[i].u.rx_sb_meta->pAuthTag[0]);
1262            hash[1]= htonl( meta[i].u.rx_sb_meta->pAuthTag[1]);
1263            hash[2]= htonl( meta[i].u.rx_sb_meta->pAuthTag[2]);
1264            stats.sb_tx+=1;
1265            if(stats.sb_tx<=16)
1266            {
1267              char *tp1 = (char *) &hash[0];
1268              //dump_header((long*)p_pkt, stats.sb_tx, (int)meta[i].u.rx_sb_meta->appId,0);
1269 #if 0
1270              printf("tag in original rx pkt=%x %x %x %x %x %x %x %x %x %x %x %x\n",
1271                       p_pkt[len-12],p_pkt[len-11],p_pkt[len-10],p_pkt[len-9], p_pkt[len-8],
1272                       p_pkt[len-7],p_pkt[len-6],
1273                       p_pkt[len-5],p_pkt[len-4],p_pkt[len-3],p_pkt[len-2],p_pkt[len-1]);
1275              printf("tag from SA=%x %x %x %x %x %x %x %x %x %x %x %x\n",
1276                        tp1[0],tp1[1],tp1[2],tp1[3],tp1[4],tp1[5],
1277                        tp1[6],tp1[7],tp1[8],tp1[9],tp1[10],tp1[11]);
1278 #endif
1279            }
1280            //put the computed tag in the packet
1281            memcpy(&p_pkt[len-12],(char*)&hash[0],12); //todo, really use meta->authTagLen
1282            {
1283            PKTIO_METADATA_T meta2 = {PKTIO_META_TX,{0},0};
1284            nwalTxPktInfo_t meta_tx={0};
1285            // now send directly 
1286            meta2.sa_handle=nwal_HANDLE_INVALID;
1287            meta_tx.txFlag1 = (NWAL_TX_FLAG1_DO_IPV4_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID);//only outer IP header checksum. no udp checksum possible since pkt is already encrypted
1288            meta_tx.startOffset = 0;
1289            meta_tx.ipOffBytes = netTest_MAC_HEADER_LEN;
1290            //not used
1291            meta_tx.l4OffBytes = 0;
1292            meta_tx.l4HdrLen = 0;
1293            meta_tx.ploadLen = 0;
1294             time = netapi_timing_start();
1295             delta_time = time -(unsigned long) meta[i].u.rx_sb_meta->appCtxId;
1296            stats.total_encrypt_time += delta_time;
1297         
1299            /* post it to netcp tx channel*/
1300            meta2.u.tx_meta=&meta_tx;
1301            pktio_send(netcp_tx_chan,tip,&meta2,&err);
1302            stats.tx +=1;
1303            }
1304         }
1305         else printf("netapi recv_sb_cb: unknown appiD %x \n",meta[i].u.rx_sb_meta->appId );
1306     }
1309 /******************************************************/
1310 /******************PKT RECEIVE HANDLER *************************/
1311 /******************************************************/
1312 void recv_cb(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
1313                          PKTIO_METADATA_T meta[], int n_pkts,
1314                          uint64_t ts )
1316 int i;
1317 int len;
1318 int p;
1319 HEAD_T * p_res;
1320 Ti_Pkt * tip;
1321 unsigned int templen;
1322 int err;
1323 KEY_T key;
1324 char * p_pkt;
1325 HEAD_T * p_head;
1326 HEAD_T temp_head;
1327 netTestSA_t *p_sa_info;
1328 uint8_t *p_spi;
1329 uint8_t p_iv[16];
1330 Cppi_HostDesc*          pPloadDesc;
1332     p_head=&temp_head;
1334     //debug
1335 #if 0
1336     if (n_pkts != TX_BURST) {
1337       printf("recv_cb, txsofar=%d rxsofar=%d  np = %d, NOT %d\n", 
1338              stats.itx, stats.rx, n_pkts,TX_BURST);
1339       our_stats_cb(netapi_handle,NULL);
1340     }
1341 #endif
1342     //test_alloc_free(7);
1343     //printf("recv start\n");
1345     /* loop over received pkts */
1346     for(i=0;i<n_pkts;i++)
1347    {
1348         tip = p_recv[i];
1349         Pktlib_getDataBuffer(tip,(uint8_t**)&p_pkt,&templen);//ignore templen
1350         len = Pktlib_getPacketLen(tip)-4;//real length, subtract mac trailer
1351         Cppi_setData (Cppi_DescType_HOST, (Cppi_Desc *) tip, p_pkt,len);
1352         Pktlib_setPacketLen(tip,len);
1354         //debug: validate descriptor */
1355         if(Pktlib_getNextPacket(tip) != 0) 
1356         {
1357             printf(" rcv_cb, nexpkt != NULL");
1358         }
1359         //debug printf("recv pkt, len=%d %d\n", len, templen);
1360         stats.rx+=1;
1362 #ifdef DEBUG_DESC
1363         if (stats.rx<16)
1364         {
1365             printf(">rx dmp.."); 
1366             dump_descr((long *) tip, stats.rx);
1367         }
1368         else if (stats.rx>99) 
1369         {
1370             printf(">rx dmp.."); 
1371             dump_descr((long *) tip,stats.rx);
1372         }
1373 #endif
1374 #if 0
1375         if(stats.rx<=16)
1376         {
1377             dump_header((long*)p_pkt, stats.rx, (int)meta[i].u.rx_meta->appId,meta[i].u.rx_meta->rxFlag1);
1378         }
1379 #endif
1380         /* check header */
1381         memcpy(p_head,&p_pkt[14],sizeof(HEAD_T));
1383         if ((p_head->ip[2]&0x0000ff00)==0x00003200)
1384         {
1385             if (!check_header(p_head,&meta[i]))
1386             {
1387                 stats.n_bad+=1;Pktlib_freePacket(tip); 
1388                 continue;
1389             }
1394             //process IP SEC PACKET
1395         if (config.ipsec_mode_rx == IPSEC_MODE_RX_SIDEBAND)
1396         {      
1397             p_spi = &(p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN]);
1398             p_sa_info = (netTestSA_t *) trie_lookup(p_trie_sa, (char *)p_spi ,4);
1399             if (p_sa_info == NULL)
1400             {
1401                 printf("recv_cb(): trie_lookup() failed\n");
1402                 continue;
1403             }
1405            //ship to crypto for decrypt!!
1406            //12 byte auth tag
1407             PKTIO_METADATA_T meta2 = {PKTIO_META_SB_TX,{0},0};
1408            nwalDmTxPayloadInfo_t meta_tx={0};
1409            meta2.sa_handle=p_sa_info->rx_data_mode_handle;
1411            memcpy(&meta_tx, &(p_sa_info->tx_payload_info), sizeof(nwalDmTxPayloadInfo_t));
1413            meta_tx.encSize = len - p_sa_info->tx_payload_info.encOffset -netTest_ICV_LEN;
1414            meta_tx.authSize = len - meta_tx.authOffset - netTest_ICV_LEN;
1416 #if 0
1417             printf("recv_cb(): encOffset %d\n", meta_tx.encOffset);
1418             printf("recv_cb():authOffset %d\n", meta_tx.authOffset);
1419             printf("recv_cb(): encSize %d\n", meta_tx.encSize);
1420             printf("recv_cb(): authSize %d\n", meta_tx.authSize);
1421 #endif
1423             if (p_sa_info->cipherMode ==  NWAL_SA_EALG_AES_CTR)
1424             {
1425                 memcpy(&p_iv[0], &ourEncrKey[16], 4);
1426                 memcpy(&p_iv[4], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
1427                 p_iv[12] = 0;
1428                 p_iv[13] = 0;
1429                 p_iv[14] = 0;
1430                 p_iv[15] = 1;
1431                  meta_tx.pEncIV = &p_iv[0];
1432             }
1433             else if (p_sa_info->cipherMode ==  NWAL_SA_EALG_NULL)
1434             {
1435                 meta_tx.pEncIV = NULL;
1436             }
1437             else
1438             {
1439                 meta_tx.pEncIV = &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN ];
1440             }
1441             meta_tx.appCtxId = (nwal_AppId)netapi_timing_start();
1442             //printf("recv_cb appCtxId: %lu\n", meta_tx.appCtxId);
1444            /* post it to netcp sb tx channel*/
1445            meta2.u.tx_sb_meta=&meta_tx;
1446 #ifdef NET_TEST_ENABLE_SIDE_BAND_LOW_LEVEL_API
1447            /* Use the command label which was cached during create time
1448             * Update the Queue to receive output packet from SA to the local 
1449             * core Queue. Below information can be saved by application in 
1450             * per process context to avoid API overhead per packet
1451             * Application can use below rxSbSaQ for polling packets back from
1452             * SA
1453             */
1454            nwalRetVal =  
1455            nwal_getLocCxtInfo(PKTIO_GET_NWAL_INSTANCE(netcp_sb_tx_chan),
1456                                                       &nwalLocCxt);
1457            if(nwalRetVal == nwal_OK)
1458            {
1459                 p_sa_info->rx_dmPSCmdInfo.rxSbSaQ = nwalLocCxt.rxSbSaQ;
1460            }
1461             nwal_mCmdDMUpdate(tip,
1462                               &p_sa_info->rx_dmPSCmdInfo,
1463                               meta_tx.appCtxId,
1464                               meta_tx.encOffset,
1465                               meta_tx.encSize,
1466                               meta_tx.pEncIV,
1467                               meta_tx.authOffset,
1468                               meta_tx.authSize,
1469                               meta_tx.pAuthIV,
1470                               meta_tx.aadSize,
1471                               meta_tx.pAad);
1472              pPloadDesc = Pktlib_getDescFromPacket(tip);
1473              pPloadDesc = Qmss_osalConvertDescVirtToPhy(pPloadDesc);
1474              Qmss_queuePushDescSizeRaw(p_sa_info->rx_dmPSCmdInfo.txQueue,
1475                                        pPloadDesc,
1476                                        NWAL_DESC_SIZE);
1478 #else
1479            pktio_send(netcp_sb_tx_chan,tip,&meta2,&err);
1480 #endif
1481            continue;
1482         }
1483         else 
1484             //inflow mode.  flip and send
1485             flip_and_send_pkt(tip,p_pkt,len,1);
1486     }
1487     else if ((p_head->ip[2]&0x0000ff00)!=0x00001100)
1488     {
1489         stats.n_new+=1;Pktlib_freePacket(tip); continue;
1490     }
1491     else  //non ipsec
1492     {
1493         if (!check_header(p_head,&meta[i])) { 
1494                 stats.n_bad+=1;Pktlib_freePacket(tip); 
1495         continue;
1496         }
1498 #if 0
1499         /* lookup flow */
1500         key.src_ip = p_head->ip[3];
1501         key.dst_ip = p_head->ip[4];
1502         key.src_port= (p_head->udp[0]&0xffff0000)>>16;
1503         key.dst_port= (p_head->udp[0]&0x0000ffff);
1504         p_res= (HEAD_T *) trie_lookup(P_trie, (char *) &key, sizeof(key));
1505         if (!p_res) { stats.n_new+=1;  slow_path(tip, len); continue;}
1507         /* copy header */
1508         memcpy((char *) p_head, (char *) p_res, sizeof(HEAD_T));
1510         memcpy(&p_pkt[14],p_head,sizeof(HEAD_T));
1511         /* update_mac(&p_pkt[0]);  */
1513         /* 'simulate' send pkt */
1514         send_pkt(tip,len);
1515 #endif
1516              //just flip and send
1517             flip_and_send_pkt(tip,p_pkt,len,0);
1518         }
1519     }
1520     //printf("recv done\n");
1523 //timer callback 
1524 void our_timer_cb( NETAPI_TIMER_GROUP_HANDLE_T th,
1525         int n_fired,     //# timers fired
1526         NETAPI_TIMER_LIST_T fired_list,
1527         uint64_t currentTime)
1529 int i;
1530 NETAPI_TIMER_T tx;
1531 int cookie;
1532 int err;
1533 unsigned long long et;
1534 //DEBUGprintf("TIMER CALLBACK @ %lld %d timers\n", currentTime, n_fired);
1535 tx = netapi_TimerGetFirst(fired_list);
1536 for(i=0;i<n_fired;i++)
1538   cookie = (int) netapi_TimerGetCookie(tx);
1539   et =  netapi_TimerGetTs(tx); //debug
1540   //DEBUGprintf("   timer %d - cookie = %d expected ts=%lld (delta=%lld)\n", i, cookie, et, currentTime-et);
1541   if (cookie ==1)
1542   {  
1543      stats.n_t1+=1;
1544      t1 = netapi_TimerGroupStartTimer(
1545         th,
1546         (void *) 1,
1547         100LL,  //timer group tics
1548         &err);
1549   }
1550   else if (cookie ==2)
1551   {
1552       stats.n_t2+=1;
1553       t2 = netapi_TimerGroupStartTimer(
1554         th,
1555         (void *) 2,
1556         200LL,  //timer group ticks
1557         &err);
1558   }
1559   else
1560   {
1561     stats.n_t3+=1;
1562     t3 = netapi_TimerGroupStartTimer(
1563         th,
1564         (void *) 3,
1565         300LL,  //timer group ticks
1566         &err);
1567     //cancel 1 and restart 1
1568    netapi_TimerGroupCancel(th,t1,&err);
1569    t1 = netapi_TimerGroupStartTimer(
1570         th,
1571         (void *) 1,
1572         100LL,  //timer group ticks
1573         &err);
1574  }
1575   tx = netapi_TimerGetNext(fired_list,tx); 
1579 void print_ipsec_stats(Sa_IpsecStats_t     *p_saIpsecStats, nwal_saAALG auth, nwal_saEALG cipher)
1581 #if 0
1582     if(retVal != nwal_OK)
1583     {
1584         System_printf("CORE: %d Error getting IP Sec Stats: Ret Status: %d \n",
1585                        retVal);
1586         return(nwal_FALSE);
1587     }
1588     if((p_saIpsecStats->pktEncHi) ||(p_saIpsecStats->pktEncLo))
1589     {
1590         printf("------------- IPSec TX (Encryption Channel) Stats BEGIN --\n");
1591     }
1592     else
1593     {
1594         printf("------------- IPSec RX (Decryption Channel) Stats BEGIN --\n");
1595     }
1596 #endif
1597     printf("\nAutentication mode: %d, Encryption Mode: %d\n", auth, cipher);
1598     printf("IPSec replayOld:0x%x,replayDup:0x%x,authFail:0x%x \n",
1599                    p_saIpsecStats->replayOld,p_saIpsecStats->replayDup,p_saIpsecStats->authFail);
1600     printf("IPSec txESN:0x%x,rxESN:0x%x,pktEncHi:0x%x,pktEncLo:0x%x,pktDecHi:0x%x,pktDecLo:0x%x \n",
1601                    p_saIpsecStats->txESN,p_saIpsecStats->rxESN,p_saIpsecStats->pktEncHi,
1602                    p_saIpsecStats->pktEncLo,p_saIpsecStats->pktDecHi,p_saIpsecStats->pktDecLo);
1605 void print_datamode_stats(Sa_DataModeStats_t     *p_saDataModeStats, nwal_saAALG auth, nwal_saEALG cipher)
1608     printf("\nAutentication mode: %d, Encryption Mode: %d\n", auth, cipher);
1609     printf(" Packets processedHi: 0x%x, Packets processed Lo:0x%x\n",
1610             p_saDataModeStats->pktHi, p_saDataModeStats->pktLo);
1616 static int np2process = NP;
1617 /******************************************************
1618  * stats callback
1619  *******************************************************/
1620 void our_stats_cb(NETAPI_T h, paSysStats_t* pPaStats)
1622 uint32_t numFreeDataPackets;
1623 uint32_t            numZeroBufferPackets;
1624 uint32_t            numPacketsinGarbage;
1625 Pktlib_HeapStats    pktLibHeapStats;
1626 int i;
1627 unsigned long long bcpp;
1628 unsigned long long bcpp_noc;
1629 unsigned long long bcpp_app;
1630 unsigned long long bcpp_tx;
1631 unsigned long long npL;
1632 unsigned long long cyclesL;
1633 unsigned long long ccyclesL; //cache cycles
1634 NETAPI_SA_STATS_T netapi_sa_stats;
1636 printf(">*****stats @ %lld\n", netapi_getTimestamp());
1637 //printf("netcp_tx_handle check %x\n", netcp_tx_chan->back);
1638 printf(">itx=%d rx=%d tx=%d bad=%d slow=%d \n>rx_class0=%d rx_class1=%d rx_class2=%d  secRx=%d  secPRX=%d sb_rx=%d sb_tx=%d auth_ok=%d sec_tx=%d\n",
1639          stats.itx, stats.rx, stats.tx, stats.n_bad, stats.n_new, 
1640          stats.n_class0_rx, stats.n_class1_rx, 
1641          stats.n_class2_rx, stats.sec_rx, stats.secp_rx, stats.sb_rx, stats.sb_tx, stats.n_auth_ok,
1642          stats.sec_tx);
1644 if (stats.rx && stats.tx)
1645     printf("decrypt time per packet(avg): %lu, encrypt  time per packet(avg): %lu\n", 
1646     (unsigned long) stats.total_decrypt_time/stats.rx, (unsigned long) stats.total_encrypt_time/stats.tx);
1647 netapi_sched_get_stats(&npL,&cyclesL,&ccyclesL);
1648 if (npL && stats.rx) {
1649    bcpp = cyclesL/npL; 
1650    bcpp_noc = (cyclesL-ccyclesL)/npL; 
1651    bcpp_app = (stats.app_cycles-stats.tx_cache_cycles)/stats.rx;
1652
1653 else {bcpp = bcpp_noc=bcpp_app=0L;}
1654 if (stats.tx)
1656     bcpp_tx = (stats.send_cycles-stats.tx_cache_cycles)/stats.tx;
1657 }else {bcpp_tx = 0L;}
1658 printf(">         ++ busy cycles pp=%lld (%lld wo cache ops) (app+tx= %lld) (tx= %lld) ++\n",
1659          bcpp,bcpp_noc,bcpp_app, bcpp_tx);
1660 if(pPaStats)
1662        printf("C1 number of packets:           %d\n", pPaStats->classify1.nPackets);
1663        printf("C1 number IPv4 packets:         %d\n", pPaStats->classify1.nIpv4Packets);
1664        printf("C1 number IPv6 packets:        %d\n", pPaStats->classify1.nIpv6Packets);
1665        printf("C1 number Custom packets:        %d\n", pPaStats->classify1.nCustomPackets);
1666        printf("C1 number SRIO packets:        %d\n", pPaStats->classify1.nSrioPackets);
1667        printf("C1 number LLC/SNAP Fail packets:        %d\n", pPaStats->classify1.nLlcSnapFail);
1668        printf("C1 number table matched:        %d\n", pPaStats->classify1.nTableMatch);
1669        printf("C1 number failed table matched: %d\n", pPaStats->classify1.nNoTableMatch);
1670        printf("C1 number IP Fragmented packets: %d\n", pPaStats->classify1.nIpFrag);
1671        printf("C1 number IP Depth Overflow: %d\n", pPaStats->classify1.nIpDepthOverflow);
1672        printf("C1 number VLAN Depth Overflow: %d\n", pPaStats->classify1.nVlanDepthOverflow);
1673        printf("C1 number GRE Depth Overflow: %d\n", pPaStats->classify1.nGreDepthOverflow);
1674        printf("C1 number MPLS Packets: %d\n", pPaStats->classify1.nMplsPackets);
1675        printf ("C1 number of parse fail:        %d\n",pPaStats->classify1.nParseFail);
1676        printf("C1 number of Invalid IPv6 Opt:  %d\n", pPaStats->classify1.nInvalidIPv6Opt);
1677        printf("C1 number of TX IP Fragments:  %d\n", pPaStats->classify1.nTxIpFrag);
1678        printf ("C1 number of silent discard:    %d\n",pPaStats->classify1.nSilentDiscard);
1679        printf("C1 number of invalid control:   %d\n", pPaStats->classify1.nInvalidControl);
1680        printf ("C1 number of invalid states:    %d\n",pPaStats->classify1.nInvalidState);
1681        printf ("C1 number of system fails:      %d\n",pPaStats->classify1.nSystemFail);
1682        printf ("C2 number Packets  :           %d\n",pPaStats->classify2.nPackets);
1683        printf ("C2 number udp           :      %d\n",pPaStats->classify2.nUdp);
1684        printf ("C2 number tcp           :      %d\n",pPaStats->classify2.nTcp);
1685        printf ("C2 number Custom       :      %d\n",pPaStats->classify2.nCustom);
1686        printf ("C2 number silent drop   :      %d\n",pPaStats->classify2.nSilentDiscard);
1687        printf ("C2 number invalid cntrl :      %d\n\n",pPaStats->classify2.nInvalidControl);
1688        printf ("C2 number Modify Stats Cmd Fail :      %d\n\n",pPaStats->modify.nCommandFail);
1690 Pktlib_getHeapStats(OurHeap, &pktLibHeapStats);
1691 printf("main heap stats>  #free=%d #zb=%d #garbage=%d\n", pktLibHeapStats.numFreeDataPackets,
1692                                 pktLibHeapStats.numZeroBufferPackets, pktLibHeapStats.numPacketsinGarbage);
1693 printf("               >  #dataBufThreshStatus=%d #dataBufStarvCounter=%d #zBufThreshStatus=%d #zBufStarvCounter=%d \n", 
1694                         pktLibHeapStats.dataBufferThresholdStatus,pktLibHeapStats.dataBufferStarvationCounter,
1695                         pktLibHeapStats.zeroDataBufferThresholdStatus, pktLibHeapStats.zeroDataBufferStarvationCounter);
1697 Pktlib_getHeapStats(specialSmall, &pktLibHeapStats);
1698 printf("specialSmall heap stats>  #free=%d #zb=%d #garbage=%d\n", pktLibHeapStats.numFreeDataPackets,
1699                                 pktLibHeapStats.numZeroBufferPackets, pktLibHeapStats.numPacketsinGarbage);
1700 printf("                       >  #dataBufThreshStatus=%d #dataBufStarvCounter=%d #zBufThreshStatus=%d #zBufStarvCounter=%d \n", 
1701                                 pktLibHeapStats.dataBufferThresholdStatus,pktLibHeapStats.dataBufferStarvationCounter,
1702                                 pktLibHeapStats.zeroDataBufferThresholdStatus, pktLibHeapStats.zeroDataBufferStarvationCounter);
1705 Pktlib_getHeapStats(specialLarge, &pktLibHeapStats);
1706 printf("specialLarge heap stats>  #free=%d #zb=%d #garbage=%d\n", pktLibHeapStats.numFreeDataPackets,
1707                                 pktLibHeapStats.numZeroBufferPackets, pktLibHeapStats.numPacketsinGarbage);
1708 printf("                       >  #dataBufThreshStatus=%d #dataBufStarvCounter=%d #zBufThreshStatus=%d #zBufStarvCounter=%d \n", 
1709                                 pktLibHeapStats.dataBufferThresholdStatus,pktLibHeapStats.dataBufferStarvationCounter,
1710                                 pktLibHeapStats.zeroDataBufferThresholdStatus, pktLibHeapStats.zeroDataBufferStarvationCounter);
1713 #if 0
1714 printf("pa2sa descriptor area dump\n");
1715 for(i=0;i<TUNE_NETAPI_CONFIG_MAX_PA_TO_SA_DESC;i++)
1717    extern long * pa2sa_descr_base;
1718    long * tip= &pa2sa_descr_base[32*i]; 
1719    dump_descr(tip, i);
1721 printf("sa2pa descriptor area dump\n");
1722 for(i=0;i<TUNE_NETAPI_CONFIG_MAX_SA_TO_PA_DESC;i++)
1724    extern long * sa2pa_descr_base;
1725    long * tip= &sa2pa_descr_base[32*i]; 
1726    dump_descr(tip, i);
1728 #endif
1729 //debug = dump timer polling stats
1730 //dump_poll_stats();
1732 #ifndef EXPERIMENTAL
1733     for (i = 0; i < MAX_SEC_INDEX; i++)
1734 #else
1735     for (i=0; i < 1;i++)
1736 #endif
1737     {
1738         /* Statistics for RX Tunnel */
1739         memset(&netapi_sa_stats, 0, sizeof(netapi_sa_stats));
1740         netapi_getSaStats(netapi_handle, sa_info[i].rx_tunnel, &netapi_sa_stats);
1741         if (netapi_sa_stats.validParams & NETAPI_IPSEC_STAT_VALID)
1742         {
1743              print_ipsec_stats(&(netapi_sa_stats.saIpsecStats), 
1744                                  rx_sa[i].authMode, 
1745                                  rx_sa[i].cipherMode);
1746         }
1747         if (netapi_sa_stats.validParams & NETAPI_SIDEBAND_DATA_MODE_STAT_VALID)
1748         {
1749             print_datamode_stats(&(netapi_sa_stats.dataModeStats),
1750                                    rx_sa[i].authMode, 
1751                                    rx_sa[i].cipherMode);
1752         }
1753         
1754         /* Statistics for TX Tunnel */
1755         memset(&netapi_sa_stats, 0, sizeof(netapi_sa_stats));
1756         netapi_getSaStats(netapi_handle, sa_info[i].tx_tunnel, &netapi_sa_stats);
1757         if (netapi_sa_stats.validParams & NETAPI_IPSEC_STAT_VALID)
1758         {
1759              print_ipsec_stats(&(netapi_sa_stats.saIpsecStats), 
1760                                  tx_sa[i].authMode, 
1761                                  tx_sa[i].cipherMode);
1762         }
1763         if (netapi_sa_stats.validParams & NETAPI_SIDEBAND_DATA_MODE_STAT_VALID)
1764         {
1765             print_datamode_stats(&(netapi_sa_stats.dataModeStats),
1766                                    tx_sa[i].authMode, 
1767                                    tx_sa[i].cipherMode);
1768         }
1769     }
1772 //******************************************************
1773 //use scheduling housekeeping callback to generate pkts
1774 //******************************************************
1775 static int done_burst=0;
1776 void house(NETAPI_SCHED_HANDLE_T * s)
1778 Ti_Pkt * tip;
1779 unsigned int len;
1780 nwalTxPktInfo_t meta_tx = {0};
1781 PKTIO_METADATA_T meta = {PKTIO_META_TX,{0},0};
1782 int err;
1783 static int house_pkts_gened=0;
1784 int p;
1785 unsigned char * pIpHdr,* pData;
1786 unsigned int vv1,vv2,vv3;
1787 unsigned int sum_vv1=0;
1788 unsigned int sum_vv2=0;
1789 unsigned int sum_vv3=0;
1790 unsigned int sum_vv4=0;
1791 unsigned int sum_vv5=0;
1793 unsigned int nwal_flow_vv1,nwal_flow_vv2;
1794 unsigned int nwal_sum_vv1=0;
1795 unsigned int nwal_sum_vv2=0;
1796 unsigned int nwal_sum_vv3=0;
1797 unsigned int nwal_sum_vv4=0;
1798 unsigned int nwal_sum_vv5=0;
1799 unsigned int nwal_sum_vv6=0;
1801 unsigned int nwal_sum_flow_vv1=0;
1802 unsigned int nwal_sum_flow_vv2=0;
1803 unsigned int cache_op_b1;
1804 unsigned int cache_op_b2;
1805 int n_c_ops;
1806 static int first =0;
1807 Cppi_HostDesc*      pPktDesc;
1809 if(done_burst)
1811   house_pkts_gened+=TX_BURST;
1812   printf("net_test> request stats at n=%d \n",house_pkts_gened);
1813   netcp_cfgReqStats(netapi_handle, our_stats_cb, 0,&err);
1814   if (err!=0) {printf("stats req failed\n");}
1815   if (house_pkts_gened >= np2process+ 100)
1816   {
1817      netapi_schedShutdown(s,NULL,&err);
1818   }
1819   return;
1821 done_burst=1;
1822 Osal_cache_op_measure_reset();
1823 memset(&meta_tx,0,sizeof(meta_tx));
1824 for(p=0;p<TX_BURST;p++) {  
1825 //reguest stats 
1826 if ((house_pkts_gened>0) && (! (house_pkts_gened%1000)) )
1828    printf("net_test> request stats at n=%d \n",house_pkts_gened);
1829    netcp_cfgReqStats(netapi_handle, our_stats_cb, 0,&err); 
1830    if (err!=0) {printf("stats req failed\n");}
1834   if (house_pkts_gened >= np2process+ 100)
1835   {
1836      //shutdown
1837      netapi_schedShutdown(s,NULL,&err);
1838      continue;
1839   }
1841   else if (house_pkts_gened >= np2process) { house_pkts_gened+=1;  continue;}
1842   
1844 /* manufacture a pkt to transmit */
1845    tip = get_pkt(house_pkts_gened, &len, OurHeap, PKT_LEN,&testPkt[0]  , TEST_PKT_LEN);
1846    if(!tip) { house_pkts_gened +=1; continue; }
1849    /* set the pkt length */
1850    vv1 = netapi_timing_start();
1851    Pktlib_setPacketLen(tip, len);
1853    /* set up meta data */
1854     meta.sa_handle=nwal_HANDLE_INVALID;
1855 //#define BENCH_UDP_SEND
1856 #ifdef BEND_UDP_SEND
1857     meta_tx.txFlag1 = (NWAL_TX_FLAG1_DO_IPV4_CHKSUM | NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID);
1858     meta_tx.startOffset = 0;
1859     //GONE in V2 meta_tx.pktLen = len;
1860     meta_tx.ipOffBytes = TEST_PKT_IP_OFFSET_BYTES;
1861     meta_tx.l4OffBytes = TEST_PKT_UDP_OFFSET_BYTES;
1862     meta_tx.l4HdrLen = TEST_PKT_UDP_HDR_LEN;
1863     //GONE in V2 meta_tx.ploadOffBytes = TEST_PKT_PLOAD_OFFSET_BYTES;
1864     meta_tx.ploadLen = TEST_PAYLOAD_LEN;
1866     Pktlib_getDataBuffer(tip,&pData,&len);
1867    if(house_pkts_gened &0x1)
1868    {
1869         memcpy(&pData[6],&config.mac1[0] ,6);
1870    }
1871     pIpHdr = pData + meta_tx.ipOffBytes;
1872     meta_tx.pseudoHdrChecksum =
1873         test_utilGetIpv4PsudoChkSum(pIpHdr,(TEST_PAYLOAD_LEN+TEST_PKT_UDP_HDR_LEN));
1874 #else
1875    Pktlib_getDataBuffer(tip,&pData,&len);
1876    if(house_pkts_gened &0x1)
1877    {
1878         memcpy(&pData[6],&config.mac1[0] ,6);
1879    }
1880     meta_tx.txFlag1 = NWAL_TX_FLAG1_META_DATA_VALID;
1881     meta_tx.startOffset = 0;
1882     meta_tx.ploadLen = TEST_PAYLOAD_LEN;
1883 #endif
1884    /* post it to netcp tx channel*/
1885    meta.u.tx_meta=&meta_tx;
1886 #ifdef DEBUG_DESC
1887    if (house_pkts_gened<16) dump_descr((long *) tip, house_pkts_gened);
1888    else if (house_pkts_gened>99) dump_descr((long *) tip,house_pkts_gened);
1889 #endif
1891    if(!first)
1892    {
1893        first++;
1894        nwal_flow_vv1= netapi_timing_stop();
1895        if(nwal_initPSCmdInfo(PKTIO_GET_NWAL_INSTANCE(netcp_tx_chan),
1896                              &meta_tx,
1897                              &flowPSCmdInfo) != nwal_OK)
1898        {
1899            printf("nwal_initPSCmdInfo() ERROR \n");
1900        }
1901        nwal_flow_vv2= netapi_timing_stop();
1902        nwal_sum_flow_vv1 += (nwal_flow_vv1-vv1); 
1903        nwal_sum_flow_vv2 += (nwal_flow_vv2-nwal_flow_vv1); 
1904    }
1905        
1906    cache_op_b1= Osal_cache_op_measure(&n_c_ops);
1907    vv2= netapi_timing_stop();
1908 #ifdef BEND_UDP_SEND
1909    nwal_mCmdSetL4CkSumPort(  tip,
1910                              &flowPSCmdInfo,
1911                              TEST_PKT_UDP_OFFSET_BYTES,
1912                              (TEST_PKT_UDP_HDR_LEN + TEST_PAYLOAD_LEN),
1913                              meta_tx.pseudoHdrChecksum,
1914                              meta_tx.enetPort);
1915 #else
1916    nwal_mCmdSetPort  (tip,
1917                       &flowPSCmdInfo,  //could be NULL
1918                       0);  //port 0 -> switch decides
1920 #endif
1922    pPktDesc = Pktlib_getDescFromPacket(tip);
1923    /* Send the packet out to transmit Q*/
1924    Qmss_queuePushDescSize (flowPSCmdInfo.txQueue, 
1925                         pPktDesc, 
1926                         NWAL_DESC_SIZE);
1927    vv3= netapi_timing_stop();
1928    cache_op_b2= Osal_cache_op_measure(&n_c_ops);
1930    sum_vv1 += (vv2-vv1);
1931    if(!house_pkts_gened)
1932    {
1933        /* first packet. Take out the PS command label creation cost */
1934        sum_vv1 = sum_vv1 - nwal_sum_flow_vv2;
1935    }
1937    sum_vv3 += (vv3-vv2)-(cache_op_b2-cache_op_b1); //sub out cache op cost
1939    // printf("pktio send. full=%d metadata=%d pktio_send=%d\n", vv3-vv1,  vv2-vv1,  vv3-vv2);
1940    
1942    stats.itx +=1;
1943    house_pkts_gened +=1;
1944  }
1946    unsigned int ccycles;
1947    ccycles =Osal_cache_op_measure(&n_c_ops);
1948    if (sum_vv1) 
1949    {
1950       printf("BURST NWAL Fast send %d pkts.  metadata=%d Cmd Label Creation Cost=%d  nwal Fast Send Cost (less cacheop)= %d n_c_ops=%d cache_op_time=%d (pp-> %d)\n", 
1951               stats.itx, sum_vv1/stats.itx,  nwal_sum_flow_vv2, sum_vv3/stats.itx, 
1952               n_c_ops, ccycles, n_c_ops? (ccycles/(n_c_ops/2)) : 0);
1953 #if 0
1954       printf("NWAL Profile Cycles: Prof1= %d,Prof2=%d,Prof3=%d,Prof4=%d,Prof5=%d ,Prof6=%d \n",
1955               nwal_sum_vv1/stats.itx,nwal_sum_vv2/stats.itx,nwal_sum_vv3/stats.itx,
1956               nwal_sum_vv4/stats.itx,nwal_sum_vv5/stats.itx,nwal_sum_vv6/stats.itx);
1957   
1958 #endif  
1960       if(stats.itx2)
1961       {
1962           printf("nwal_flowSend Profile Cycles: Prof1= %d,Prof2=%d \n",
1963               nwal_sum_flow_vv1/stats.itx2,nwal_sum_flow_vv2/stats.itx2);
1964       }
1966    }
1970 void  build_sa_db(int i)
1973     if ((tx_sa[i].authMode == NWAL_SA_AALG_HMAC_SHA1) && (tx_sa[i].cipherMode == NWAL_SA_EALG_AES_CBC))
1974     {
1975         /* static configuration, will not change */
1976         sa_info[i].tx_payload_info.aadSize = 0;
1977         sa_info[i].tx_payload_info.pAad = NULL;
1978         sa_info[i].tx_payload_info.pAuthIV = NULL;
1979         sa_info[i].tx_payload_info.authOffset = netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN;        /*done: same for all cipher suites */         
1980         sa_info[i].tx_payload_info.encOffset = netTest_MAC_HEADER_LEN +
1981                                                                      netTest_IP_HEADER_LEN +
1982                                                                     netTest_ESP_HEADER_LEN +
1983                                                                     netTest_AES_CBC_IV_LEN;
1985        
1987         /* dynamic configuration, will  be calculated on the fly */
1988         sa_info[i].tx_payload_info.authSize = 0; /* pkt len - mac - ip -icv (12) */
1989         sa_info[i].tx_payload_info.encSize = 0;   /* authSize - esp header size (always 8 bytes) */
1990         sa_info[i].tx_payload_info.pEncIV = 0;
1991         sa_info[i].tx_payload_info.pPkt = 0;     /* not being referenced in net_test */
1993         sa_info[i].cipherMode = NWAL_SA_EALG_AES_CBC;
1994         sa_info[i].inner_ip_offset = sa_info[i].tx_payload_info.encOffset;
1995         sa_info[i].auth_tag_size = netTest_ICV_LEN;  /* icv or mac size,. always 12 except for AES_CCM/AES_GCM */
1996 #ifdef EXPERIMENTAL
1997         sa_info[i].iv_len=16;
1998         sa_info[i].bl=16;
1999         sa_info[i].spi = tx_sa[i].spi;
2000         sa_info[i].src =*((unsigned int *)(&config.local_ipsec_ip.ipv4[0]));
2001         sa_info[i].dst =*((unsigned int *)(&config.remote_ipsec_ip.ipv4[0]));
2002 #endif
2003         sa_info[i].tx_pkt_info.enetPort = 0;
2004         sa_info[i].tx_pkt_info.ipOffBytes = sa_info[i].tx_payload_info.encOffset;
2005         sa_info[i].tx_pkt_info.l4HdrLen = netTest_UDP_HEADER_LEN; /*UDP header len */
2006         sa_info[i].tx_pkt_info.l4OffBytes = sa_info[i].inner_ip_offset + netTest_IP_HEADER_LEN;
2007         sa_info[i].tx_pkt_info.startOffset = 0;
2008         sa_info[i].tx_pkt_info.lpbackPass = 0;
2009         sa_info[i].tx_pkt_info.ploadLen = 0; /*sa_info[i].tx_pkt_info.l4OffBytes + 4 */
2010         sa_info[i].tx_pkt_info.pPkt = NULL;
2011         sa_info[i].tx_pkt_info.saOffBytes = netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN;
2012         sa_info[i].tx_pkt_info.saPayloadLen = 0;
2013         sa_info[i].tx_pkt_info.pseudoHdrChecksum =0;
2014        
2015         sa_info[i].tx_pkt_info.txFlag1 = NWAL_TX_FLAG1_DO_IPSEC_ESP_CRYPTO| NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID ;
2017          trie_insert(p_trie_sa,(char *)&(tx_sa[i].spi),4, (void *) &sa_info[i]); //asociate with tx sa SPI
2018          
2019     }
2020     else if ((tx_sa[i].authMode == NWAL_SA_AALG_HMAC_SHA2_256) && (tx_sa[i].cipherMode == NWAL_SA_EALG_AES_CTR))
2021     {
2022         printf("inside build_sa_db, index %d\n", i);
2023         /* static configuration, will not change */
2024         sa_info[i].tx_payload_info.aadSize = 0;
2025         sa_info[i].tx_payload_info.pAad = NULL;
2026         sa_info[i].tx_payload_info.pAuthIV = NULL;
2027         sa_info[i].tx_payload_info.authOffset = netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN;        /*done: same for all cipher suites */
2028         sa_info[i].tx_payload_info.encOffset = netTest_MAC_HEADER_LEN +
2029                                                                      netTest_IP_HEADER_LEN +
2030                                                                     netTest_ESP_HEADER_LEN +
2031                                                                     netTest_AES_CTR_IV_PACKET_LEN;
2036         /* dynamic configuration, will  be calculated on the fly */
2037         sa_info[i].tx_payload_info.authSize = 0;
2038         sa_info[i].tx_payload_info.encSize = 0;
2039         sa_info[i].tx_payload_info.pEncIV = 0;
2040         sa_info[i].tx_payload_info.pPkt = 0;
2042         sa_info[i].cipherMode = NWAL_SA_EALG_AES_CTR;
2043         sa_info[i].inner_ip_offset = sa_info[i].tx_payload_info.encOffset;
2044         sa_info[i].auth_tag_size = netTest_ICV_LEN;  /* icv or mac size,. always 12 except for AES_CCM/AES_GCM */
2045 #ifdef EXPERIMENTAL
2046         sa_info[i].iv_len=8;
2047         sa_info[i].bl=8;
2048         sa_info[i].spi = tx_sa[i].spi;
2049         sa_info[i].src =*((unsigned int *)(&config.local_ipsec_ip.ipv4[0]));
2050         sa_info[i].dst =*((unsigned int *)(&config.remote_ipsec_ip.ipv4[0]));
2051 #endif
2053         sa_info[i].tx_pkt_info.enetPort = 0;
2054         sa_info[i].tx_pkt_info.ipOffBytes = sa_info[i].tx_payload_info.encOffset;
2055         sa_info[i].tx_pkt_info.l4HdrLen = netTest_UDP_HEADER_LEN; /*UDP header len */
2056         sa_info[i].tx_pkt_info.l4OffBytes = sa_info[i].inner_ip_offset + netTest_IP_HEADER_LEN;
2057         sa_info[i].tx_pkt_info.startOffset = 0;
2058         sa_info[i].tx_pkt_info.lpbackPass = 0;
2059         sa_info[i].tx_pkt_info.ploadLen = 0; /*sa_info[i].tx_pkt_info.l4OffBytes + 4 */
2060         sa_info[i].tx_pkt_info.pPkt = NULL;
2061         sa_info[i].tx_pkt_info.saOffBytes = netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN;
2062         sa_info[i].tx_pkt_info.saPayloadLen = 0;
2063         sa_info[i].tx_pkt_info.pseudoHdrChecksum =0;
2064        
2065         sa_info[i].tx_pkt_info.txFlag1 = NWAL_TX_FLAG1_DO_IPSEC_ESP_CRYPTO| NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID ;
2067        trie_insert(p_trie_sa,(char *)&(tx_sa[i].spi),4, (void *) &sa_info[i]); //asociate with tx sa SPI
2068     }
2069     else if ((tx_sa[i].authMode == NWAL_SA_AALG_HMAC_SHA2_256) && (tx_sa[i].cipherMode == NWAL_SA_EALG_3DES_CBC))
2070     {
2071         /* static configuration, will not change */
2072         sa_info[i].tx_payload_info.aadSize = 0;
2073         sa_info[i].tx_payload_info.pAad = NULL;
2074         sa_info[i].tx_payload_info.pAuthIV = NULL;
2075         sa_info[i].tx_payload_info.authOffset = netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN;        /*done: same for all cipher suites */
2076         sa_info[i].tx_payload_info.encOffset = netTest_MAC_HEADER_LEN +
2077                                                                      netTest_IP_HEADER_LEN +
2078                                                                     netTest_ESP_HEADER_LEN +
2079                                                                     netTest_3DES_CBC_IV_LEN;
2081         /* dynamic configuration, will  be calculated on the fly */
2082         sa_info[i].tx_payload_info.authSize = 0;
2083         sa_info[i].tx_payload_info.encSize = 0;
2084         sa_info[i].tx_payload_info.pEncIV = 0;
2085         sa_info[i].tx_payload_info.pPkt = 0;
2087         sa_info[i].cipherMode = NWAL_SA_EALG_3DES_CBC;
2088         sa_info[i].inner_ip_offset = sa_info[i].tx_payload_info.encOffset;
2089         sa_info[i].auth_tag_size = netTest_ICV_LEN;  /* icv or mac size,. always 12 except for AES_CCM/AES_GCM */
2090 #ifdef EXPERIMENTAL
2091         sa_info[i].iv_len=8;
2092         sa_info[i].bl=8;
2093         sa_info[i].spi = tx_sa[i].spi;
2094         sa_info[i].src =*((unsigned int *)(&config.local_ipsec_ip.ipv4[0]));
2095         sa_info[i].dst =*((unsigned int *)(&config.remote_ipsec_ip.ipv4[0]));
2096 #endif
2098         sa_info[i].tx_pkt_info.enetPort = 0;
2099         sa_info[i].tx_pkt_info.ipOffBytes = sa_info[i].tx_payload_info.encOffset;
2100         sa_info[i].tx_pkt_info.l4HdrLen = netTest_UDP_HEADER_LEN; /*UDP header len */
2101         sa_info[i].tx_pkt_info.l4OffBytes = sa_info[i].inner_ip_offset + netTest_IP_HEADER_LEN;
2102         sa_info[i].tx_pkt_info.startOffset = 0;
2103         sa_info[i].tx_pkt_info.lpbackPass = 0;
2104         sa_info[i].tx_pkt_info.ploadLen = 0; /*sa_info[i].tx_pkt_info.l4OffBytes + 4 */
2105         sa_info[i].tx_pkt_info.pPkt = NULL;
2106         sa_info[i].tx_pkt_info.saOffBytes = netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN;
2107         sa_info[i].tx_pkt_info.saPayloadLen = 0;
2108         sa_info[i].tx_pkt_info.pseudoHdrChecksum =0;
2109        
2110         sa_info[i].tx_pkt_info.txFlag1 = NWAL_TX_FLAG1_DO_IPSEC_ESP_CRYPTO| NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID ;
2112        trie_insert(p_trie_sa,(char *)&(tx_sa[i].spi),4, (void *) &sa_info[i]); //asociate with tx sa SPI
2113     }
2114     else if ((tx_sa[i].authMode == NWAL_SA_AALG_HMAC_MD5) && (rx_sa[i].cipherMode == NWAL_SA_EALG_NULL))
2115     {
2116         /* static configuration, will not change */
2117         sa_info[i].tx_payload_info.aadSize = 0;
2118         sa_info[i].tx_payload_info.pAad = NULL;
2119         sa_info[i].tx_payload_info.pAuthIV = NULL;
2120         sa_info[i].tx_payload_info.authOffset = netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN;        /*done: same for all cipher suites */
2122         sa_info[i].tx_payload_info.encOffset =         netTest_MAC_HEADER_LEN +
2123                                                                      netTest_IP_HEADER_LEN +
2124                                                                     netTest_ESP_HEADER_LEN +
2125                                                                     netTest_NULL_IV_LEN;
2126 #ifdef EXPERIMENTAL
2127         sa_info[i].iv_len=0;
2128         sa_info[i].bl=4;
2129         sa_info[i].spi = tx_sa[i].spi;
2130         sa_info[i].src =*((unsigned int *)(&config.local_ipsec_ip.ipv4[0]));
2131         sa_info[i].dst =*((unsigned int *)(&config.remote_ipsec_ip.ipv4[0]));
2132 #endif
2135         /* dynamic configuration, will  be calculated on the fly */
2136         sa_info[i].tx_payload_info.authSize = 0;
2137         sa_info[i].tx_payload_info.encSize = 0;
2138         sa_info[i].tx_payload_info.pEncIV = 0;
2139         sa_info[i].tx_payload_info.pPkt = 0;
2141         sa_info[i].cipherMode = NWAL_SA_EALG_NULL;
2142         sa_info[i].inner_ip_offset = sa_info[i].tx_payload_info.encOffset;
2143         sa_info[i].auth_tag_size = netTest_ICV_LEN;  /* icv or mac size,. always 12 except for AES_CCM/AES_GCM */
2145         sa_info[i].tx_pkt_info.enetPort = 0;
2146         sa_info[i].tx_pkt_info.ipOffBytes = sa_info[i].tx_payload_info.encOffset;
2147         sa_info[i].tx_pkt_info.l4HdrLen = netTest_UDP_HEADER_LEN; /*UDP header len */
2148         sa_info[i].tx_pkt_info.l4OffBytes = sa_info[i].inner_ip_offset + netTest_IP_HEADER_LEN;
2149         sa_info[i].tx_pkt_info.startOffset = 0;
2150         sa_info[i].tx_pkt_info.lpbackPass = 0;
2151         sa_info[i].tx_pkt_info.ploadLen = 0; /*sa_info[i].tx_pkt_info.l4OffBytes + 4 */
2152         sa_info[i].tx_pkt_info.pPkt = NULL;
2153         sa_info[i].tx_pkt_info.saOffBytes = netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN;
2154         sa_info[i].tx_pkt_info.saPayloadLen = 0;
2155         sa_info[i].tx_pkt_info.pseudoHdrChecksum =0;
2156        
2157         sa_info[i].tx_pkt_info.txFlag1 = NWAL_TX_FLAG1_DO_IPSEC_ESP_CRYPTO| NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID ;
2159        trie_insert(p_trie_sa,(char *)&(tx_sa[i].spi),4, (void *) &sa_info[i]); //asociate with tx sa SPI
2160     }
2161     else
2162         printf("build_sa_db(): invalid encryption/authentication combination selected\n");
2164     //printf("sa_build_db(): authOffset %d, innerIpOffset %d, encOffset %d\n", sa_info[i].tx_payload_info.authOffset, sa_info[i].inner_ip_offset, sa_info[i].tx_payload_info.encOffset);
2165     
2166     
2171 #define CHECK_SET_PARAM(ARG1, ARG2)     \
2172     do { \
2173         if(strcmp(key, ARG1) == 0) { \
2174         if(data)strncpy(ARG2,data,CONFIG_STRING_LEN); \
2175         printf("CHECK_SET_PARM, match found, input cong string %s\n", ARG2); \
2176         continue; \
2177         } \
2178     } while(0)
2180 #define CHECK_SET_PARAM2(ARG1, ARG2,  ARG3)     \
2181     do { \
2182         if(strcmp(key, ARG1) == 0) { \
2183         if(data) strncpy(ARG2,data,CONFIG_STRING_LEN); \
2184         if(data2) strncpy(ARG3,data2,CONFIG_STRING_LEN); \
2185         printf("CHECK_SET_PARM, match found, input cong string %s %s\n", ARG2, ARG3); \
2186         continue; \
2187         } \
2188     } while(0)
2190 unsigned char hex2dec(char *p_s)
2192   int val;
2193   sscanf(p_s,"%x",&val); 
2194  return val&0xff;
2196 void parse_one_mac(char * p_mac_str, unsigned char *p_mac)
2198     int index = 0;
2199     int i;
2200     char *pch = strtok (&(p_mac_str[0]),"-");
2202     while (pch != NULL)
2203     {
2204          printf ("%s\n",pch);
2205          p_mac[index] = hex2dec(pch);
2206          index++;
2207          pch = strtok (NULL,"-");
2208     }
2209      printf("index value : %d\n", index);
2210     for (i=0; i<6;i++)
2211          printf("************mac0[%d]: 0x%x\n",i,  p_mac[i]);
2214 void parse_one_ip(char * p_ip_addr_str, unsigned char * p_ip)
2216     int index = 0;
2217     int i;
2218     char * pch = strtok (&p_ip_addr_str[0],".");
2220      while (pch != NULL)
2221      {
2222         printf ("xxxxx: %s\n",pch);
2223         p_ip[index] = atoi(pch);
2224         index++;
2225         pch = strtok (NULL,".");
2226     }
2227     printf("index value : %d\n", index);
2228     for (i=0; i<4;i++)
2229         printf("************ip[%d]: 0x%x\n",i, p_ip[i]);
2234 void parse_mac_address(netTestConfigFile_t *pConfig)
2236     if (strlen(&pConfig->mac0[0]))
2237         parse_one_mac(&pConfig->mac0[0],&config.mac0[0]);
2238     if (strlen(&pConfig->mac1[0]))
2239         parse_one_mac(&pConfig->mac1[0],&config.mac1[0]);
2241 void parse_ip_address(netTestConfigFile_t *pConfig)
2243     if (strlen(&pConfig->ip0[0]))
2244         parse_one_ip(&pConfig->ip0[0],&config.ip0.ipv4[0]);
2245     if (strlen(&pConfig->ip1[0]))
2246         parse_one_ip(&pConfig->ip1[0],&config.ip1.ipv4[0]);
2247     if (strlen(&pConfig->ip2[0]))
2248         parse_one_ip(&pConfig->ip2[0],&config.ip2.ipv4[0]);
2249     if (strlen(&pConfig->local_ipsec_ip[0]))
2250         parse_one_ip(&pConfig->local_ipsec_ip[0],&config.local_ipsec_ip.ipv4[0]);
2251     if (strlen(&pConfig->remote_ipsec_ip[0]))
2252     parse_one_ip(&pConfig->remote_ipsec_ip[0],&config.remote_ipsec_ip.ipv4[0]);
2256 void parse_ipsec_mode(netTestConfigFile_t *pConfig)
2259     printf("parse_ipsec_mode, string length %d\n", strlen(&pConfig->ipsec_mode_rx));
2260     if (strlen(&pConfig->ipsec_mode_rx[0]))
2261     {
2262         if (strcmp(pConfig->ipsec_mode_rx, "SIDEBAND") == 0)
2263         {
2264             config.ipsec_mode_rx = IPSEC_MODE_RX_SIDEBAND;
2265         }
2266         else if (strcmp(pConfig->ipsec_mode_rx, "INFLOW") == 0)
2267         {
2268             config.ipsec_mode_rx = IPSEC_MODE_RX_INFLOW;
2269         }
2270         else
2271             printf("parse_ipsec_mode(), invalid RX ipsec mode in config file \n");
2272     }
2274     if (strlen(&pConfig->ipsec_mode_tx[0]))
2275     {
2276         if (strcmp(pConfig->ipsec_mode_tx, "SIDEBAND") == 0)
2277         {
2278             config.ipsec_mode_tx = IPSEC_MODE_TX_SIDEBAND;
2279         }
2280         else if (strcmp(pConfig->ipsec_mode_tx, "INFLOW") == 0)
2281         {
2282             config.ipsec_mode_tx = IPSEC_MODE_TX_INFLOW;
2283         }
2284     else
2285         printf("parse_ipsec_mode(), invalid TX ipsec mode in config file \n");
2286     }
2288     printf("parse_ipsec_mode(): RX mode %d\n", config.ipsec_mode_rx);
2289     printf("parse_ipsec_mode(): TX mode %d\n", config.ipsec_mode_tx);
2291     
2294 #ifdef EXPERIMENTAL
2295 int n_routes=0;
2296 int n_dst_ips=0;
2297 void parse_routes(netTestConfigFile_t *pConfig)
2299 int i;
2300 int said=0;
2301 for(i=0;i<MAX_ROUTES;i++)
2303    int port;
2304    if (pConfig->routes[i][0])
2305    {
2306       port=atoi(&pConfig->ports[i][0]);
2307       if((port<1)||(port>2)) continue; //bad port #: only 1 or 2 valid
2308       if(strncmp(&pConfig->routes[i][0],"MAC",3)==0)
2309       {
2310          routes[i].out_port = port;
2311          parse_one_mac(&pConfig->routes[i][3],&routes[i].out_mac[0]);
2312          memcpy(&routes[i].out_mac[6], ((port==1) ?&config.mac0[0]: &config.mac1[0] ),6); 
2313          routes[i].out_mac[12]=0x08;
2314          routes[i].out_mac[13]=0x00;
2315          routes[i].sec_ptr=NULL;
2316          n_routes+=1;
2317       }
2318       else if (strncmp(&pConfig->routes[i][0],"SA",2)==0)
2319       {      
2320          said=atoi(&pConfig->routes[i][2]) ;
2321          routes[i].sec_ptr=&sa_info[said];
2322          n_routes+=1;
2323       }
2324    }
2326 our_router = route_init();
2327 for (i=0;i<MAX_ROUTES;i++)
2329   unsigned long ip_be;
2330   int route_index;
2331   if (pConfig->dst_ips[i][0])
2332   {
2333      parse_one_ip(&pConfig->dst_ips[i][0],(unsigned char *)&ip_be);
2334      sscanf(&pConfig->paths[i][0],"route%d",&route_index);
2335      route_add(our_router,&ip_be,&routes[route_index]);
2336      n_dst_ips+=1;
2337   }
2339 printf(">Route DB built.  %d entries\n",n_dst_ips);
2341 #endif
2342 static void parse_config_file(FILE * fpr, netTestConfigFile_t *pConfig)
2344     char line[MAX_LINE_LENGTH + 1];
2345     int i;
2346  
2347     char *key, *data, *ep, *data2;
2348     char tokens[] = " :=;\n";
2349     char temp_str[50];
2350     memset(line, 0, MAX_LINE_LENGTH + 1);
2351     memset(pConfig, 0, sizeof(netTestConfigFile_t));
2352     while (fgets(line, MAX_LINE_LENGTH + 1, fpr)) 
2353     {
2354         if(line[0]=='#') continue; //skip comment
2355         key  = (char *)strtok(line, tokens);
2356         data = (char *)strtok(NULL, tokens);
2357         data2 = (char *)strtok(NULL, tokens);
2358         if (!key) continue;
2359         if (!data) continue;
2361         if(strlen(data) == 0) 
2362         {
2363             continue;
2364         }
2366          CHECK_SET_PARAM(INIT_CONFIG_MAC0,&(pConfig->mac0[0]));
2367          CHECK_SET_PARAM(INIT_CONFIG_MAC1,&(pConfig->mac1[0]));
2368          CHECK_SET_PARAM(INIT_CONFIG_IP0,&(pConfig->ip0[0]));
2369          CHECK_SET_PARAM(INIT_CONFIG_IP1,&(pConfig->ip1[0]));
2370          CHECK_SET_PARAM(INIT_CONFIG_IP2,&(pConfig->ip2[0]));
2371          CHECK_SET_PARAM(INIT_CONFIG_LOCAL_IPSEC_IP,&(pConfig->local_ipsec_ip[0]));
2372          CHECK_SET_PARAM(INIT_CONFIG_REMOTE_IPSEC_IP,&(pConfig->remote_ipsec_ip[0]));
2373          CHECK_SET_PARAM(INIT_CONFIG_IPSEC_MODE_RX,&(pConfig->ipsec_mode_rx[0]));
2374          CHECK_SET_PARAM(INIT_CONFIG_IPSEC_MODE_TX,&(pConfig->ipsec_mode_tx[0]));
2375          CHECK_SET_PARAM(INIT_CONFIG_IPSEC_IF_NO,&(pConfig->ipsec_if_no[0]));
2376 #ifdef EXPERIMENTAL
2377     for(i=0;i<MAX_ROUTES;i++)
2378     {
2379         sprintf(temp_str,"route%d",i);
2380         CHECK_SET_PARAM2(temp_str,&pConfig->routes[i][0],&pConfig->ports[i][0] );
2381     }
2382     for(i=0;i<MAX_ROUTES;i++)
2383     {
2384         sprintf(temp_str,"dstip%d",i);
2385         CHECK_SET_PARAM2(temp_str,&pConfig->dst_ips[i][0],&pConfig->paths[i][0] );
2386     }
2387 #endif
2388          
2389     }
2390     parse_mac_address(pConfig);
2392     parse_ip_address(pConfig);
2394     parse_ipsec_mode(pConfig);
2395 #ifdef EXPERIMENTAL
2396      if (strlen(&pConfig->ipsec_if_no[0]))
2397         config.ipsec_if_no = atoi(&pConfig->ipsec_if_no[0]);
2398     parse_routes(pConfig);
2399 #endif
2402 static  netTestConfigFile_t config_file;
2403 /***************************************
2404  ********** test driver*****************
2405  ***************************************/
2406 int main(int argc, char **argv)
2408     int err,i;
2409     rlim_t oss,ss = 1024*1024;
2410     struct rlimit rl;
2412     Pktlib_HeapCfg      heapCfg;
2413     int32_t             errCode;
2414     Pktlib_HeapIfTable*  pPktifTable;
2415  
2416     FILE * fpr = NULL;
2420     err= getrlimit(RLIMIT_STACK,&rl);
2421     if (!err) printf(" stack limit = %d\n",rl.rlim_cur); else printf("getrlimit failed\n");
2422 #if 0
2423     rl.rlim_cur = ss;
2424     err=setrlimit(RLIMIT_STACK,&rl);
2425 i   f (!err) printf("set stack to %d\n",rl.rlim_cur); else printf("setrlimit failed\n");
2426 #endif
2429     if (argc>=2)  np2process = atoi(argv[1]);
2430         printf("*************** np2process %d\n", np2process);
2431     if (np2process<0) np2process = NP; /* default */
2432     if (argc==3)  perslow = atoi(argv[2]);
2433     if ((perslow<0)||(perslow>100)) perslow=PERSLOW;//default
2434     if (argc>3) {printf("net_test  <no of pkts to process> <percent slow path>\n"); exit(1);}
2435 #if 1
2437 #if 0
2438     if (argc >= 2) 
2439     {
2440         fpr = fopen(argv[2], "r");
2441         if (fpr == NULL) 
2442         {
2443             printf("Error in opening %s input file\n", argv[2]);
2444         }
2445     } 
2446     else
2447 #endif
2448     {
2449         fpr = fopen(input_file_name, "r");
2450         if (fpr == NULL) 
2451         {
2452             printf("Error in opening %s input file\n", input_file_name);
2453         }
2454         else
2455         {
2456             parse_config_file(fpr,&config_file);
2457         }
2458     }
2460 #endif
2462     memset(&sa_info, 0, sizeof(sa_info));
2465 //real mode, so update our test packet mac header and ip header
2466 if (pktloopback==0)
2468 memcpy(&testPkt,&real_mac_header[0],14); //overwrite test pkt mac address
2469 memcpy(&testPkt[26],&real_ip_addr[0],8);//overrite test pkt ip addresses
2471 #if 0 
2472 our_router = route_init();
2473 for (i=0;i<n_dst_ips;i++)
2475   route_add(our_router,&ip[i],&routes[i]);
2477 #endif
2479 /*******************************************/
2480 /*************NETAPI STARTUP****************/
2481 /*******************************************/
2483 /* create netapi */
2484 netapi_handle = netapi_init(NETAPI_SYS_MASTER, &our_netapi_default_cfg);
2486 /* open the main heap */
2487 OurHeap = Pktlib_findHeapByName("netapi");
2488 if (!OurHeap) {printf("findheapbyname fail\n"); exit(1);}
2490 /* create two secondary heaps */
2491 /* Initialize the heap configuration. */
2492 memset ((void *)&heapCfg, 0, sizeof(Pktlib_HeapCfg));
2494 pPktifTable = netapi_getPktlibIfTable();
2495 /* Populate the heap configuration */
2496 heapCfg.name                = "netapi-small";
2497 heapCfg.memRegion           = NETAPI_GLOBAL_REGION;
2498 heapCfg.sharedHeap          = 1;
2499 heapCfg.useStarvationQueue  = 0;
2500 heapCfg.dataBufferSize      = 512;
2501 heapCfg.numPkts             = 64;
2502 heapCfg.numZeroBufferPackets= 0;
2503 heapCfg.heapInterfaceTable.data_malloc  = pPktifTable->data_malloc;
2504 heapCfg.heapInterfaceTable.data_free    = pPktifTable->data_free;
2505 heapCfg.dataBufferPktThreshold   = 0;
2506 heapCfg.zeroBufferPktThreshold   = 0;
2508 specialSmall = Pktlib_createHeap(&heapCfg, &errCode);
2509 heapCfg.name                = "netapi-big";
2510 heapCfg.dataBufferSize      = 1600;
2511 specialLarge = Pktlib_createHeap(&heapCfg, &errCode);
2512 //register these heaps so poll routine will include their garbage queues.
2513 netapi_registerHeap(netapi_handle, specialSmall);
2514 netapi_registerHeap(netapi_handle, specialLarge);
2516 #ifdef REASSEMBLE_BENCH
2517 our_reassemble_bench(2);
2518 exit(1);
2519 #endif
2521 #ifndef EXPERIMENTAL
2522 /* create a pktio channel */
2523 our_chan=pktio_create(netapi_handle,"our1stq",(PKTIO_CB) recv_cb_bench, &our_chan_cfg,&err);
2524 if (!our_chan) {printf("pktio create failed err=%d\n",err); exit(1);}
2525 #endif
2527 /* open netcp default tx, rx queues */
2528 netcp_tx_chan= pktio_open(netapi_handle, NETCP_TX, NULL, &netcp_tx_cfg,  &err);
2529 if (!netcp_tx_chan) {printf("pktio open TX failed err=%d\n",err); exit(1);}
2530 #ifdef EXPERIMENTAL
2531 netcp_rx_chan= pktio_open(netapi_handle, NETCP_RX, (PKTIO_CB) recv_cb_router, &netcp_rx_cfg,  &err);
2532 #else
2533 netcp_rx_chan= pktio_open(netapi_handle, NETCP_RX, (PKTIO_CB) recv_cb, &netcp_rx_cfg,  &err);
2534 #endif
2535 if (!netcp_rx_chan) {printf("pktio open RX failed err=%d\n",err); exit(1);}
2537 #ifndef EXPERIMENTAL
2538 /* create a pktio channel for specially classified pkts */
2539 netcp_rx_chan2= pktio_create(netapi_handle, "classq", (PKTIO_CB) recv_cb, &netcp_rx_cfg2,  &err);
2540 if (!netcp_rx_chan2) {printf("pktio create RX2 failed err=%d\n",err); exit(1);}
2542 /* open netcp default tx, rx queues for sideband crypto */
2543 netcp_sb_tx_chan= pktio_open(netapi_handle, NETCP_SB_TX, NULL, &netcp_sb_tx_cfg,  &err);
2544 if (!netcp_sb_tx_chan) {printf("pktio open SB TX failed err=%d\n",err); exit(1);}
2545 netcp_sb_rx_chan= pktio_open(netapi_handle, NETCP_SB_RX, (PKTIO_CB) recv_sb_cb, &netcp_sb_rx_cfg,  &err);
2546 if (!netcp_sb_rx_chan) {printf("pktio open SB RX failed err=%d\n",err); exit(1);}
2547 #endif
2549 printf("net_test> %d bytes left in our CMA area\n", netapi_getBufMemRemainder());
2550 /* create scheduler instance */
2551 our_sched =netapi_schedOpen(netapi_handle,&our_sched_cfg, &err);
2552 if (!our_sched) {printf("sched create failed\n"); exit(1);}
2554 #if 0
2555 /********************************************
2556 * Basic pkt loopback test
2557 *********************************************/
2558 printf("...running pure push/pop benchmark\n");
2559 our_pktio_bench(1000);
2560 our_pktio_bench(1000);
2561 our_pktio_bench(1000);
2562 our_pktio_bench(1000);
2563 our_pktio_bench(1000);
2564 /*********************************************/
2565 #endif
2570 /* add mac intefaces */
2571 netcp_cfgCreateMacInterface(
2572                   netapi_handle,
2573                   &config.mac0[0],
2574                   0,0,
2575                   (NETCP_CFG_ROUTE_HANDLE_T)  NULL,
2576                   (NETCP_CFG_VLAN_T ) NULL ,  //future
2577                   1, 
2578                   &err);
2579 if (err) {printf("addmac0 failed %d\n",err); exit(1); } 
2581 //attach an IP to this interface
2582 ip_rule0=netcp_cfgAddIp(
2583                   netapi_handle,
2584                   0,
2585                   nwal_IPV4,
2586                   &config.ip0,
2587                   NULL,  //all IP
2588                   (NETCP_CFG_ROUTE_HANDLE_T) NULL,
2589                   &err
2590                   );
2591 if (err) {printf("addip0 failed %d\n",err); exit(1); } 
2593 //create a 2nd mac instance
2594 netcp_cfgCreateMacInterface(
2595                   netapi_handle,
2596                   &config.mac1[0],
2597                   1,1,
2598                   (NETCP_CFG_ROUTE_HANDLE_T)  NULL,
2599                   (NETCP_CFG_VLAN_T ) NULL ,  //future
2600                   1,
2601                   &err);
2602 if (err) {printf("addmac1 failed %d\n",err); exit(1); }
2604 //attach an IP to this interface
2605 ip_rule1=netcp_cfgAddIp(
2606                   netapi_handle,
2607                   1,
2608                   nwal_IPV4,
2609                   &config.ip1,
2610                   NULL,  //all IP
2611                   (NETCP_CFG_ROUTE_HANDLE_T) NULL,
2612                   &err
2613                   );
2614 if (err) {printf("addip1 failed %d\n",err); exit(1); }
2616 #ifndef EXPERIMENTAL
2617 //attach 2 classifiers to iface 0, ip0
2618 class_0_cfg.u.c_l4.ip = ip_rule0;
2619 class_0 =  netcp_cfgAddClass(netapi_handle,
2620                              &class_0_cfg,
2621                              NULL,
2622                              NETCP_CFG_ACTION_TO_SW,
2623                              &err);
2624 if (err) {printf("addclass0 failed %d\n",err); exit(1);}
2626 class_1_cfg.u.c_l4.ip = ip_rule0;
2627 class_1 =  netcp_cfgAddClass(netapi_handle,
2628                              &class_1_cfg,
2629                              NULL,
2630                              NETCP_CFG_ACTION_TO_SW,
2631                              &err);
2632 if (err) {printf("addclass1 failed %d\n",err); exit(1);}
2635 //3rd classifier has a different IP and route
2636 class_2_cfg.u.c_l3_l4.ip_addr = &config.ip2;
2638 //create specialFlow for this classifier
2640 Pktlib_HeapHandle heaps[2];
2641 int sizes[2];
2642 heaps[0]= specialSmall;
2643 heaps[1]= specialLarge;
2644 #define SPECIAL_SOP_OFF 128
2645 sizes[0]=512-SPECIAL_SOP_OFF;
2646 sizes[1]=1600-SPECIAL_SOP_OFF;
2647 #if 0
2648 specialFlow = netcp_cfgAddFlow( netapi_handle,
2649                                 2,
2650                                 heaps,
2651                                 sizes,
2652                                 SPECIAL_SOP_OFF,  //offset to start rx is 128 
2653                                 &err);
2654 if (err) {printf("add flow failed\n", err); exit(1);}
2655 #endif
2657 #if 0
2658 //special route for this classifier:  different flow + destination q
2659 class2_route.p_dest_q = netcp_rx_chan2;
2660 class2_route.p_flow = specialFlow;
2661 class_2 = netcp_cfgAddClass(netapi_handle,
2662                             &class_2_cfg,
2663                             (void*) &class2_route,
2664                             NETCP_CFG_ACTION_TO_SW,
2665                             &err);
2666 if (err) {printf("addclass2 failed %d\n",err); exit(1);}
2667 #endif
2669 #endif
2670 //security stuff 
2671     p_trie_sa = trie_new();
2672    if (!p_trie_sa) {printf("trie alloc for SA  failed\n"); exit(1);}
2676     for (i=0; i < MAX_SEC_INDEX;i++)
2677     {
2678         ourRXKeyParams[i].pEncKey = &ourEncrKey[0];
2679         ourRXKeyParams[i].pAuthKey = &ourAuthKey[0];
2680         memcpy(&(rx_sa[i].src), &config.remote_ipsec_ip,4);
2681         memcpy(&(rx_sa[i].dst), &config.local_ipsec_ip,4);
2683         build_sa_db(i);
2684         sa_info[i].rx_tunnel = netapi_secAddSA(
2685             netapi_handle,
2686             config.ipsec_if_no, //iface #0 
2687             &rx_sa[i],
2688             &ourRXKeyParams[i],
2689             config.ipsec_mode_rx == IPSEC_MODE_RX_SIDEBAND ? NETAPI_SEC_SA_SIDEBAND: NETAPI_SEC_SA_INFLOW,
2690                 NULL,  //use default route 
2691             &(sa_info[i].rx_data_mode_handle),
2692             &(sa_info[i].rx_inflow_mode_handle),
2693             &err);
2694         if (err) {printf("addRxSa failed %d\n",err); exit(1);}
2696         if (config.ipsec_mode_rx == IPSEC_MODE_RX_INFLOW)
2697         {
2698             //assume inner and outer ip is the same
2699             rx_policy[i]= netapi_secAddRxPolicy( netapi_handle,
2700                              sa_info[i].rx_tunnel,  //link to tunnel above
2701                              4,         //ipv4
2702                              &config.remote_ipsec_ip, //src -> them
2703                              &config.local_ipsec_ip,  //dst -> us
2704                             NULL,  // no qualifiers
2705                             NULL,  //default route
2706                              &err);
2707             if (err) {printf("addSaPolicy failed  %d, for index %d\n",err,i); exit(1);}
2708         }
2709         else 
2710         {
2711             rx_policy[i] = 0;
2712              
2713         }
2714 #ifdef NET_TEST_ENABLE_SIDE_BAND_LOW_LEVEL_API
2715     /* Remember the NetCP Command Label so save cycles per Crypto 
2716      * operation
2717      * 
2718      */
2719     if(config.ipsec_mode_rx == IPSEC_MODE_RX_SIDEBAND)
2720     {
2721             nwalRetVal =  
2722             nwal_initDMPSCmdInfo(PKTIO_GET_NWAL_INSTANCE(netcp_sb_rx_chan),
2723                                  sa_info[i].rx_data_mode_handle,
2724                                  &sa_info[i].rx_dmPSCmdInfo);
2725     }
2727 #endif
2728     }
2730 //tx SA
2731 //security stuff 
2732      for (i=0; i < MAX_SEC_INDEX;i++)
2733     {
2734     ourTXKeyParams[i].pEncKey = &ourEncrKey[0];
2735     ourTXKeyParams[i].pAuthKey = &ourAuthKey[0];
2736     memcpy(&(tx_sa[i].src), &config.local_ipsec_ip,4);
2737     memcpy(&(tx_sa[i].dst), &config.remote_ipsec_ip,4);
2738     sa_info[i].tx_tunnel = netapi_secAddSA( netapi_handle,
2739                  0, //iface #0 
2740                 &(tx_sa[i]),
2741                 &ourTXKeyParams[i],
2742                 config.ipsec_mode_tx == IPSEC_MODE_TX_SIDEBAND ? NETAPI_SEC_SA_SIDEBAND: NETAPI_SEC_SA_INFLOW,
2743                 NULL,  //use default route 
2744                 &(sa_info[i].tx_data_mode_handle),
2745                 &(sa_info[i].tx_inflow_mode_handle),
2746                 &err);
2747 if (err) {printf("addTxSa failed %d\n",err); exit(1);}
2749 #ifdef NET_TEST_ENABLE_SIDE_BAND_LOW_LEVEL_API
2750     /* Remember the NetCP Command Label so save cycles per Crypto 
2751      * operation
2752      * 
2753      */
2754     if(config.ipsec_mode_tx == IPSEC_MODE_TX_SIDEBAND)
2755     {
2756             nwalRetVal =  
2757             nwal_initDMPSCmdInfo(PKTIO_GET_NWAL_INSTANCE(netcp_sb_tx_chan),
2758                                  sa_info[i].tx_data_mode_handle,
2759                                  &sa_info[i].tx_dmPSCmdInfo);
2760     }
2762 #endif
2763     }
2765 #ifdef TEST_TIMERS
2766 //timers
2767 ourTimerBlock = netapi_TimerGroupCreate(
2768         netapi_handle,
2769         "our1sttimer",
2770         our_timer_cb,
2771         0,    //1 if timers local to thread
2772         0,    //1 if expect to cancel
2773         netapi_getTicksPerSec()/1000,  /* 1 msc resolution for these timers */
2774         netapi_getTicksPerSec()/5000, /* would like .5 msc tolerence */
2775         10,  //small # of timers to test garbage collection
2776         &err);
2777 if (err) {printf("timergroupcreate failed %d\n",err); exit(1);}
2779 //start a couple of timers 
2780 t1 = netapi_TimerGroupStartTimer(
2781         ourTimerBlock,
2782         (void *) 1,
2783         100LL,  //timer group ticks
2784         &err);
2785 if (err) {printf("timerstart failed %d\n");}
2786 t2 = netapi_TimerGroupStartTimer(
2787         ourTimerBlock,
2788         (void *) 2,
2789         200LL,  //timer group ticks
2790         &err);
2791 if (err) {printf("timerstart failed %d\n");}
2792 t3 = netapi_TimerGroupStartTimer(
2793         ourTimerBlock,
2794         (void *) 3,
2795         300LL,  //timer group ticks
2796         &err);
2797 if (err) {printf("timerstart failed %d\n");}
2798 #endif
2799 netcp_cfgReqStats(netapi_handle, our_stats_cb, 1,&err);
2800 if (err!=0) {printf("stats req failed\n");}
2802 /*********************************************/
2803 /*****************end NETAPI STARTUP**********/
2804 /*********************************************/
2807 #if 0
2808 /********************************************
2809 * Basic pkt loopback test
2810 *********************************************/
2811 printf("...runnining pure push/pop benchmark\n");
2812 our_pktio_bench(100);
2813 #endif
2815 /**************unused stuff******************/
2816 #if 0
2817 /* create TRIE */
2818 P_trie = trie_new();
2819 if (!P_trie) {printf("trie alloc failed\n"); exit(1);}
2821 nat = (HEAD_T *) malloc(NE * sizeof(HEAD_T));
2822 if (!nat) {printf("malloc of nat table failed\n"); exit(1);}
2824 //gen_pkts(np2process<NP ? np2process:NP);
2825 n_pkt= np2process;
2827 /* build table */
2828 build_table(P_trie);
2831 /* processing loop: get pkt, check it, look up in table, copy new header,
2832    send packet */
2833 srand((unsigned) np2process);
2834 #endif
2836 /*********************************************/
2837 /**************Entry point into scheduler ****/
2838 /*********************************************/
2839 netapi_schedWaitForEvents(our_sched, &err);
2841 /* done */
2842 our_stats_cb(netapi_handle, NULL);
2845 #define DO_FAST_POLL
2846 #ifdef DO_FAST_POLL
2847 //example_fast_pushpop(OurHeap, 500);
2848 //example_fast_poll(netcp_rx_chan,20000);
2849 #endif
2851 /*************************************************
2852  ************CLEAN UP****************************
2853  ************************************************/
2855 #ifndef EXPERIMENTAL
2856 //delete Classifiers
2857 netcp_cfgDelClass(netapi_handle, class_0, &err); 
2858 netcp_cfgDelClass(netapi_handle, class_1, &err); 
2859 //netcp_cfgDelClass(netapi_handle, class_2, &err); 
2861 #if 0
2862 //delete flow 
2863 netcp_cfgDelFlow(netapi_handle, specialFlow, &err);
2864 #endif
2865 #endif
2866 #if 1
2867 //delete policy
2868      for (i=0; i < MAX_SEC_INDEX;i++)
2869     {
2870         if (rx_policy[i])
2871             netapi_secDelRxPolicy(netapi_handle, rx_policy[i], &err);
2872      
2873         //delete tunnels
2874         netapi_secDelSA(netapi_handle, 0, sa_info[i].rx_tunnel, &err);
2875         netapi_secDelSA(netapi_handle, 0, sa_info[i].tx_tunnel, &err);
2876 #endif
2877     }
2878 //delete IPs and MAC Interfacess
2879 netcp_cfgDelIp(netapi_handle, 0, 0, NULL, NULL, ip_rule0, &err);
2880 netcp_cfgDelIp(netapi_handle, 1, 0, NULL, NULL, ip_rule1, &err);
2881 netcp_cfgDelMac(netapi_handle,0,&err);
2882 netcp_cfgDelMac(netapi_handle,1,&err);
2885 //close pktio channels we opened
2886 pktio_close(netcp_tx_chan ,&err);
2887 pktio_close(netcp_rx_chan ,&err);
2888 #ifndef EXPERIMENTAL
2889 pktio_close(netcp_sb_tx_chan ,&err);
2890 pktio_close(netcp_sb_rx_chan ,&err);
2892 //clear pktio channel we created
2893 pktio_control(our_chan, (PKTIO_CB) NULL, (PKTIO_CFG_T *) NULL, &zap_channel_control, &err);
2894 pktio_control(netcp_rx_chan2, (PKTIO_CB) NULL, (PKTIO_CFG_T *) NULL, &zap_channel_control, &err);
2896 //delete pktio channels we created
2897 pktio_delete(our_chan, &err);
2898 pktio_delete(netcp_rx_chan2,&err);
2899 #endif
2900 netapi_shutdown(netapi_handle);
2904 //EXAMPLE FAST POLL
2905 /* PLD */
2906 void netapi_pld(void * x)
2907 {   
2908            asm volatile("pld [r0]");
2910 #include "ti/drv/nwal/nwal_util.h"
2912 #define M 1008
2913 static int l3_off[M], l4_off[M], L3_chk_ok[M], L4_chk_ok[M], len[M] ;
2914 static nwal_AppId appid[M];
2915 static unsigned char * buf[M];
2916 #define N2POLL 8 //batch size
2917 #define NTOPOP 190
2918 Ti_Pkt * pHd[NTOPOP];
2919 void example_fast_pushpop(Pktlib_HeapHandle h , int n_trials)
2921 int i,j;
2922 unsigned long t1;
2923 unsigned long t2;
2924 unsigned long sumf=0;
2925 unsigned long sumt=0;
2926 unsigned long sump=0;
2927 #define NTOPOP 190
2928 Ti_Pkt * tempVA;
2929 Qmss_QueueHnd freeQ=Pktlib_getInternalHeapQueue(h);
2931 //n_trials of NTOPOP actions
2932 for(i=0;i<n_trials;i++)
2934     //raw pop
2935     t1= netapi_timing_start();
2936     pHd[0] = (Ti_Pkt *)QMSS_DESC_PTR(PKTIO_QMSS_QUEUE_POP_RAW (freeQ));
2937     for(j=1;j<NTOPOP;j++)
2938     {
2939        tempVA  =  _Osal_qmssPhyToVirt(pHd[j-1]);
2940        netapi_pld(tempVA);
2941         //__builtin_prefetch(tempVA);
2942        pHd[j] = (Ti_Pkt *)QMSS_DESC_PTR(PKTIO_QMSS_QUEUE_POP_RAW (freeQ));
2943        sumf+= (int) (   ((Cppi_HostDesc *) tempVA)->origBuffPtr -
2944                   ((Cppi_HostDesc *) tempVA)->buffPtr);
2945     }
2946     tempVA  =  _Osal_qmssPhyToVirt(pHd[j-1]);
2947     sumf+= (int) (   ((Cppi_HostDesc *) tempVA)->origBuffPtr -
2948                   ((Cppi_HostDesc *) tempVA)->buffPtr);
2949     t2=netapi_timing_stop();
2950     sumt+= (t2-t1);
2952     //invalidate/wb 
2953     for(j=0;j<NTOPOP;j++)
2954     {
2955         tempVA  =  _Osal_qmssPhyToVirt(pHd[j]);
2956         netapi_utilCacheWbInv(tempVA,128);
2957     }
2959     //raw push 
2960     t1=netapi_timing_start();
2961     for(j=0;j<NTOPOP;j++)
2962     {
2963         PKTIO_QMSS_QUEUE_PUSH_DESC_SIZE_RAW (freeQ,
2964                                              (void *) pHd[j],
2965                                              128);
2966     }
2967     t2=netapi_timing_stop();
2968     sump += (t2-t1);
2970 printf("\nfast poppush: np=%d  pop=%d  push=%d sumf=%d\n", (n_trials*NTOPOP),
2971         sumt/(n_trials*NTOPOP),  sump/(n_trials*NTOPOP), sumf);
2972 sleep(1);
2973 return;
2978 void example_fast_poll( PKTIO_HANDLE_T * p_pktio, int max_pkts)
2980 int j=0;
2981 int jj=0;
2982 int i,k,l=0,ltot=0;
2983 int n= N2POLL; //max # of pkts to poll
2984 Ti_Pkt * tempVA;
2985 pasahoLongInfo_t* pinfo;
2986 unsigned long t1;
2987 unsigned long t2;
2988 unsigned long t11;
2989 unsigned long t12;
2990 unsigned long np;
2991 unsigned long sumt=0;
2992 unsigned long sumf=0;
2993 unsigned long sump=0;
2994 unsigned long totlen=0;
2995 int max_batch=0;
2997 //this should  be done once and saved
2998 Qmss_QueueHnd rxQ= PKTIO_GET_DEFAULT_NETCP_Q(p_pktio);
2999 Qmss_QueueHnd freeQ;
3000 //loop forever
3001 for(;max_pkts>0;)
3003     t1= netapi_timing_stop();
3004     pHd[0] = (Ti_Pkt *)QMSS_DESC_PTR(PKTIO_QMSS_QUEUE_POP_RAW (rxQ));
3005     if (!pHd[0]) continue;
3006     //got pkt
3007     for(i=1;(i<n) && (pHd[i-1]);i++)
3008     {
3009         //convert previous descriptor PA -> VA
3010         tempVA  =  Osal_qmssPhyToVirt(pHd[i-1]); 
3012         //try and preload desriptor
3013          __builtin_prefetch(tempVA);
3014         //netapi_pld(tempVA);
3016         //read next descriptor from queue 
3017         pHd[i] = (Ti_Pkt *)QMSS_DESC_PTR(PKTIO_QMSS_QUEUE_POP_RAW (rxQ));
3018 #if 1   
3019         /* extract some meta data */
3020         Cppi_getData (Cppi_DescType_HOST, (Cppi_Desc*)tempVA, &buf[jj], &len[jj]);
3021         pinfo =  nwal_mGetProtoInfo(tempVA);
3022         l3_off[jj]= nwal_mGetL3OffBytes(pinfo);
3023         l4_off[jj]= nwal_mGetL4Offset(pinfo);
3024         if(nwal_mGetAppidFmPkt(tempVA,&appid[jj]) != nwal_TRUE)
3025         {
3026             printf("ERROR!!!! AppID not available in incoming packet \n");
3027         }
3028 //#define VERIFY_SOP
3029 #ifdef VERIFY_SOP
3030   if (sump < 200)  printf("..sop off=%d\n", (int) buf[jj]-
3031            (int)  ((Cppi_HostDesc *) tempVA)->origBuffPtr) ;
3032 #endif
3033 #endif
3034         jj+=1;
3035     }
3036     //finish last pkt in burst
3037     if(pHd[i-1])
3038     {
3039         //convert previous descriptor PA -> VA
3040         tempVA  =  Osal_qmssPhyToVirt(pHd[i-1]); 
3042         /* extract some meta data */
3043 #if 1
3044         pinfo =  nwal_mGetProtoInfo(tempVA);
3045         l3_off[jj]= nwal_mGetL3OffBytes(pinfo);
3046         l4_off[jj]= nwal_mGetL4Offset(pinfo);
3047         if(nwal_mGetAppidFmPkt(tempVA,&appid[jj]) != nwal_TRUE)
3048         {
3049             printf("ERROR!!!! AppID not available in incoming packet \n");
3050         }
3051 #endif
3052         //get ptr (Physical address) and length of associate buffer
3053         Cppi_getData (Cppi_DescType_HOST, (Cppi_Desc*)tempVA, &buf[jj], &len[jj]);
3054         jj+=1;
3055     }
3056     t2= netapi_timing_stop();
3057     j+=(pHd[i-1]? i: (i-1)) ;
3058     if (jj>(M-n)) jj=0;
3059     l+=1;  //n batches
3060     ltot+=1;
3061     if(pHd[i-1])
3062     {
3063       if (i>max_batch) max_batch= i;
3064     }
3065     else
3066     {
3067       if( (i-1) >max_batch) max_batch = i-1;
3068     }
3070     //cleanup
3071     //printf("cleanup %d\n",i);
3072     for(k=0;k<i;k++)
3073     {
3074         //cleanup.  need to covert all of desriptor to VA so that i can use freePacket() 
3075         //alternative would be to just do cache ops plus descriptor raw push to pktlib
3076         // heap free queue
3077         if(pHd[k])
3078         {
3080         //tempVA=Qmss_osalConvertDescPhyToVirt(pHd[k]);
3081         tempVA  =  Osal_qmssPhyToVirt(pHd[k]);
3082         freeQ=Qmss_getQueueHandle(Cppi_getReturnQueue (Cppi_DescType_HOST, (Cppi_Desc *)tempVA));
3083         netapi_utilCacheWbInv(tempVA,128);
3084         //would need to wbInv buffer also in practice. Also need to walk
3085         // descriptor chain 
3086         t11= netapi_timing_stop();
3087        // Pktlib_freePacket(tempVA);
3088         PKTIO_QMSS_QUEUE_PUSH_DESC_SIZE_RAW (freeQ,
3089                                              (void *) pHd[k],
3090                                              128);
3092         t12= netapi_timing_stop();
3093         sumf += (t12-t11);       
3094         }
3095     }
3096     sumt += (t2-t1);
3097     sump +=(pHd[i-1]? i: (i-1));
3098     max_pkts -= (pHd[i-1]? i: (i-1));
3100     //printf("end cleanup %d %d %d\n",sumt,sumf,sump );
3101     if (sump > 10000) {
3102        printf("pkts rx %d batches=%d  appid=%x l3_off=%d l4_off=%d len=%d buf=0x%x rxcycle= %d pkts/batchx1000=%d maxbatch=%d cycles per rawpush = %d\n", 
3103                   j,ltot, appid[j%M], 
3104                   l3_off[j%M],l4_off[j%M],  
3105                   len[j%M],buf[j%M],
3106                    sumt/sump,  (sump*1000)/l, max_batch,
3107                    sumf/sump);
3108        sumt=sump=sumf=0;
3109        l=0;
3110     }
3113     //cleanup any remaining buffers
3114     for(;;)
3115     {
3116         pHd[0] = (Ti_Pkt *)QMSS_DESC_PTR(PKTIO_QMSS_QUEUE_POP_RAW (rxQ));
3117         if(!pHd[0]) break;
3118         tempVA  =  Osal_qmssPhyToVirt(pHd[0]);
3119         freeQ=Qmss_getQueueHandle(Cppi_getReturnQueue (Cppi_DescType_HOST, (Cppi_Desc *)tempVA));
3120         netapi_utilCacheWbInv(tempVA,128);
3121         PKTIO_QMSS_QUEUE_PUSH_DESC_SIZE_RAW (freeQ,
3122                                              (void *) pHd[0],
3123                                              128);
3124     }
3127 #ifdef EXPERIMENTAL
3129 static inline void send_it(Ti_Pkt *tip, int len, ROUTE_SEC_T * p_sec)
3131   unsigned long st1;
3132   unsigned long st2;
3133   int err=0;
3134   PKTIO_METADATA_T meta2 = {PKTIO_META_TX,{0},0};
3135   nwalTxPktInfo_t meta_tx2={0};
3136   st1=netapi_timing_start();
3137   if (len<60) 
3138   { 
3139      unsigned int templen;
3140      char * p_pkt;
3141      len=60; 
3142      Pktlib_getDataBuffer(tip,(uint8_t**)&p_pkt,&templen);//ignore templen
3143      Cppi_setData (Cppi_DescType_HOST, (Cppi_Desc *) tip, p_pkt,len);
3144      stats.tx_min+=1;
3145   }
3146   Pktlib_setPacketLen(tip,len);
3147   meta_tx2.txFlag1 = (NWAL_TX_FLAG1_DO_IPV4_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID );
3148   meta_tx2.startOffset = 0;
3149   meta_tx2.ipOffBytes = 14;
3150   meta_tx2.ploadLen = len ;
3151   if(p_sec)
3152   {   
3153        meta_tx2.txFlag1 |= NWAL_TX_FLAG1_DO_IPSEC_ESP_CRYPTO ;
3154        meta2.sa_handle=p_sec->tx_inflow_mode_handle; //this tells netapi that inflow crypto needs to be applied
3155        meta_tx2.enetPort=0;
3156        meta_tx2.saOffBytes=14+20;
3157        meta_tx2.saPayloadLen=len-14-20;   //don't include tag, mac and outer header
3158        stats.sec_tx+=1;
3159   }
3160   meta2.u.tx_meta=&meta_tx2;
3161   pktio_send(netcp_tx_chan,tip,&meta2,&err);
3162   stats.tx +=1;
3163   st2=netapi_timing_start();
3164   stats.send_cycles += (unsigned long long) (st2-st1);  
3165
3166 void recv_cb_router(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
3167                          PKTIO_METADATA_T meta[], int n_pkts,
3168                          uint64_t ts )
3170 int i;
3171 int len;
3172 int p;
3173 Ti_Pkt * tip;
3174 unsigned int templen;
3175 char * p_pkt;
3176 HEAD_T temp_head;
3177 unsigned int appid;
3178 IP_HEAD_T th;
3179 ROUTE_SEC_T *sec_data=NULL;
3180 unsigned long t1;
3181 unsigned long t2;
3182 unsigned long ct1;
3183 unsigned long ct2;
3184 unsigned short ip_pl;
3185 int n_c_ops;
3186 t1=netapi_timing_start();
3187 ct1 =Osal_cache_op_measure(&n_c_ops);
3188 for(i=0;i<n_pkts;i++)
3190         tip = p_recv[i];
3191         Pktlib_getDataBuffer(tip,(uint8_t**)&p_pkt,&templen);//ignore templen
3192         len = Pktlib_getPacketLen(tip)-4;//real length, subtract mac trailer
3193         stats.rx+=1;
3194         appid = ((unsigned int)meta[i].u.rx_meta->appId)&0xff000000;
3195         switch(appid)
3196         {
3197            case(NETAPI_NETCP_MATCH_IPSEC):
3198            case(NETAPI_NETCP_MATCH_IPSEC_POLICY):
3199            {
3200              int tailen=12+2;
3201              memcpy(&temp_head,&p_pkt[14],sizeof(HEAD_T));
3202              if (!check_header(&temp_head,&meta[i])) {
3203                 stats.n_bad+=1;
3204                 Pktlib_freePacket(tip); 
3205                 continue;
3206              }
3207              tailen+=p_pkt[len-12-2]; //padding length  (12)should come from sec_ptr
3208              p_pkt = &p_pkt[8+16+20];   //16= iv len, should come from sec_ptr
3209              len -= (8+16+20+tailen);  //16= iv len should come from sec ptr
3210             
3211              //now check inner headder.
3212              memcpy(&th,&p_pkt[14],20);
3213              if (!check_header(&temp_head,&meta[i])) {
3214                 stats.n_bad+=1;
3215                 Pktlib_freePacket(tip);
3216                 continue;
3217              }
3218              Cppi_setData (Cppi_DescType_HOST, (Cppi_Desc *) tip, p_pkt,len);
3219              Pktlib_setPacketLen(tip,len);
3220              
3221              if (route_pkt(our_router, tip, &th, p_pkt, &len,&sec_data)<0)
3222               {
3223                 stats.n_bad+=1;
3224                 Pktlib_freePacket(tip);
3225              }
3226              else
3227              {
3228                send_it(tip,len,sec_data);
3229              }
3230              break;
3231            }
3232            case(NETAPI_NETCP_MATCH_GENERIC_MAC):
3233               if((p_pkt[12]!=0x8)||(p_pkt[13]!=0x00)) 
3234               {
3235                 stats.n_new+=1;
3236                 Pktlib_freePacket(tip); 
3237                 continue;
3238               }
3239               if (!check_header(&temp_head,&meta[i])) 
3240               {
3241                 stats.n_bad+=1;
3242                 Pktlib_freePacket(tip);
3243                 continue;
3244               }
3245               memcpy(&th,&p_pkt[14],20);
3246               ip_pl= (((unsigned char *)&th.w1)[2]<<8) | ((unsigned char *)&th.w1)[3];
3247               if ((ip_pl+14)<60)
3248               {
3249                 len-= (60-(ip_pl+14));
3250                 stats.rx_min+=1;
3251               }
3252               Pktlib_setPacketLen(tip,len);
3253               if (route_pkt(our_router, tip, &th, p_pkt, &len,&sec_data)<0)
3254               {
3255                 stats.n_bad+=1;
3256                 Pktlib_freePacket(tip);
3257               }
3258               else
3259               {
3260                  send_it(tip,len,sec_data);
3261               }
3262               break;
3263            case(NETAPI_NETCP_MATCH_GENERIC_IP):
3264               Pktlib_freePacket(tip); 
3265               stats.n_new=1;
3266               break;
3267            default:
3268               stats.n_new+=1;
3269               Pktlib_freePacket(tip);
3270               break;
3271        }
3273 t2=netapi_timing_start();
3274 ct2 =Osal_cache_op_measure(&n_c_ops);
3275 stats.app_cycles +=  (unsigned long long) (t2-t1);
3276 stats.tx_cache_cycles += (unsigned long long) (ct2-ct1);
3277 return;
3279 #endif