e6f79e18ac82fae16dbdf2d84a4d6fa50cd48720
[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:
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  *****************************************************************************/
45 #include "net_test.h"
46 #include "ti/drv/nwal/test/fw_rm.h"
47 #include <signal.h>
48 #include <pthread.h>
50 extern int QUIT;
51 extern netTestStats_T stats[TUNE_NETAPI_NUM_CORES];
52 extern paSysStats_t netcp_stats;
54 #ifdef netTest_MULTI_THREAD
55     cpu_set_t cpu_set;
56 #endif
58 netTestConfig_t netTestCfg;
59 static netTestConfigFile_t config_file;
61 char    input_file_name[] = "net_test_config.txt";
63 nwal_RetValue       nwalRetVal;
64 Pktlib_HeapHandle   ourHeap;
66 PKTIO_HANDLE_T *netcp_rx_chan;
67 PKTIO_HANDLE_T *netcp_tx_chan_no_crypto;
68 PKTIO_HANDLE_T *netcp_tx_chan_esp;
69 PKTIO_HANDLE_T *netcp_tx_chan_ah;
70 PKTIO_HANDLE_T *netcp_sb_tx_chan;
71 PKTIO_HANDLE_T *netcp_sb_rx_chan;
73 PKTIO_CFG_T netcp_rx_cfg={PKTIO_RX, PKTIO_NA, PKTIO_NA, 8};
74 PKTIO_CFG_T netcp_rx_cfg2={PKTIO_RX, (PKTIO_GLOBAL|PKTIO_PKT), PKTIO_Q_ANY, 8};
75 PKTIO_CFG_T netcp_tx_cfg={PKTIO_TX, PKTIO_NA, PKTIO_NA, 8};
76 PKTIO_CFG_T netcp_sb_rx_cfg={PKTIO_RX, PKTIO_NA, PKTIO_NA, 8};
77 PKTIO_CFG_T netcp_sb_tx_cfg={PKTIO_TX, PKTIO_NA, PKTIO_NA, 8};
79 NETCP_CFG_IP_T ip_rule[NET_TEST_MAX_IP];
80 NETCP_CFG_MACIF_T mac[NET_TEST_MAX_MAC];
82 #ifdef netTest_DSP_FASTPATH
83 PKTIO_HANDLE_T *dsp_pktio_channels[CPU_NUM_REM_FAST_PATH_CORES];
84 NETCP_CFG_CLASS_T dsp_classifers[CPU_NUM_REM_FAST_PATH_CORES];
85 NETCP_CFG_FLOW_HANDLE_T dsp_flow_handles[CPU_NUM_REM_FAST_PATH_CORES];
86 #endif
87 NETCP_CFG_EXCEPTION_PKT_T expPkt_appid;
89 Trie *p_trie_sa_rx;
90 Trie *p_trie_sa_tx;
93 /*******************************************
94  *************NETAPI OBJECTS***************
95  *****************************************/
96 static NETAPI_CFG_T our_netapi_default_cfg=
97 {
98     TUNE_NETAPI_PERM_MEM_SZ,
99     128,  //start of packet offset for hw to place data on rx for default flow
100     TUNE_NETAPI_QM_CONFIG_MAX_DESC_NUM, //max number of descriptors in system
101     TUNE_NETAPI_NUM_GLOBAL_DESC,        //total we will use
102     TUNE_NETAPI_DEFAULT_NUM_BUFFERS,   //#descriptors+buffers in default heap
103     64, //#descriptors w/o buffers in default heap
104     TUNE_NETAPI_DEFAULT_BUFFER_SIZE+128+128,  //size of buffers in default heap
105     128   ,  //tail room
106     256      //extra room
107 };
109 NETAPI_T netapi_handle;
110 NETAPI_SCHED_HANDLE_T * our_sched;
111 #ifdef netTest_MULTI_THREAD
112 NETAPI_SCHED_HANDLE_T * scheduler[TUNE_NETAPI_NUM_CORES];
113 #endif
114 NETAPI_SCHED_CONFIG_T our_sched_cfg={
115   NETAPI_SCHED_DURATION|NETAPI_SCHED_CBV, 0, house, 5000000  //every 5000000 poll loops
116 };
118 netTestSA_t sa_info[MAX_SEC_INDEX];
119 NETCP_CFG_IPSEC_POLICY_T rx_policy[MAX_SEC_INDEX];
126 /********************************************************************
127  * FUNCTION PURPOSE:  Utility function to flip and packet and send
128  *                    it back to its source.
129  ********************************************************************
130  * DESCRIPTION:   Utility function to flip and packet and send
131  *                    it back to its source.
132  ********************************************************************/
133 void flip_and_send_pkt(Ti_Pkt *tip,  unsigned char * p_pkt, int len, int flag, uint16_t enet_port)
135     unsigned char mac_temp[6];
136     unsigned char ip_temp[4];
137     unsigned char new_dest_port[2]={0x75,0x30};  // 30000
138     uint16_t dest_udp_port_config = 0;
139     uint16_t blah; 
140     uint16_t i=1;   /* for testing only */
142     uint8_t *p_spi; 
143     netTestSA_t * p_sa_info;
144     netTestSA_t *p_sa_info_tx;
145     uint8_t p_iv[16];
146     uint8_t p_add[8];
147     Cppi_HostDesc*          pPloadDesc;
148     uint8_t ah_len;
149     uint32_t tunnel_id;
150     nwalLocCxtInfo_t    nwalLocCxt;
151     netTestHead_T * p_head;
152     netTestHead_T temp_head;
153     int pkt_type;
155 #ifdef netTest_MULTI_THREAD
156     int coreid=Osal_nwalGetProcId(); //who we are(thread local)
157         //int coreid = our_core;
158 #else
159 int coreid=0;
160 #endif
161               // netTest_utilDumpBuffer((long*)p_pkt,len);
162     Pktlib_setPacketLen(tip,len);
163     //flip the mac address
164     memcpy(&mac_temp,&p_pkt[0],6);
165     memcpy(&p_pkt[0],&p_pkt[6],6);
166     memcpy(&p_pkt[6],&mac_temp,6);
167     //memcpy(&p_pkt[0],real_mac_header,6); //for testing to wireshark pc
169     //flip the ip  (outer in case of ipsec)
170     memcpy(&ip_temp, &p_pkt[14+12],4);
171     memcpy(&p_pkt[14+12],&p_pkt[14+12+4],4);
172     memcpy(&p_pkt[14+12+4],&ip_temp,4);
174     p_head=&temp_head;
176     //inner ip &udp for ipsec
177     if (flag) 
178     {
179         memcpy(p_head,&p_pkt[14],sizeof(netTestHead_T));
181         if ((p_head->ip[2]&0x0000ff00)==0x00003300)
182         {
183             p_spi = &(p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN + 4]);
184             pkt_type = netTest_IPSEC_AH_PKT;
185         }
186         else if ((p_head->ip[2]&0x0000ff00)==0x00003200)
187         {
188             p_spi = &(p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN]);
189             pkt_type = netTest_IPSEC_ESP_PKT;
190         }
191         else
192         {
193             netapi_Log("flip_and_send_pkt: un-supported IPSEC protocol\n");
194             Pktlib_freePacket(tip);
195             return;
196         }
198         p_sa_info = (netTestSA_t *) trie_lookup(p_trie_sa_rx, (char *)p_spi ,4);
199         if (p_sa_info == NULL)
200         {
201             netapi_Log("flip_and_send_pkt(): trie_lookup() failed\n");
202             Pktlib_freePacket(tip);
203             return;
204         }
205         tunnel_id = p_sa_info->tunnel_id;
206         p_sa_info_tx = (netTestSA_t *) trie_lookup(p_trie_sa_tx, (char *)&tunnel_id ,4);
207         if (p_sa_info_tx == NULL)
208         {
209             netapi_Log("flip_and_send_pkt(): trie_lookup() failed\n");
210             Pktlib_freePacket(tip);
211             return;
212         }
213         //just drop non-udp packet
214         if (p_pkt[p_sa_info->tx_payload_info.encOffset+9]!=0x11)
215         {
216             stats[coreid].n_new+=1;Pktlib_freePacket(tip); return;
217         }
219         /* flip inner IP */
220         memcpy(&ip_temp, &p_pkt[p_sa_info->tx_payload_info.encOffset+12],4);
221         memcpy(&p_pkt[p_sa_info->tx_payload_info.encOffset+12],&p_pkt[p_sa_info->tx_payload_info.encOffset+12+4],4);
222         memcpy(&p_pkt[p_sa_info->tx_payload_info.encOffset+12+4],&ip_temp,4);
223         /* setting udp ports */
224         if (netTestCfg.dest_udp_port_config == 0)
225         {
226             printf("dest_udp_port_config is 0, use src port as dest port\n");
227             memcpy(&p_pkt[p_sa_info->tx_payload_info.encOffset+20+2],&p_pkt[p_sa_info->tx_payload_info.encOffset+20],2);
228         }
229         else
230         {
231            dest_udp_port_config = htons(netTestCfg.dest_udp_port_config);
232             memcpy(&p_pkt[p_sa_info->tx_payload_info.encOffset+20+2],&dest_udp_port_config,2);
233         }
234         memset(&p_pkt[p_sa_info->tx_payload_info.encOffset+20+6],0,2); //checksum
236         if (netTestCfg.ipsec_mode_tx == IPSEC_MODE_TX_SIDEBAND)
237         {
238             /* inner ip checksum : leave alone, outer ip, set to 0 (we will compute on way out */
239             memset(&p_pkt[14+10],0,2);
240         }
241     }
242     else
243     {
244         /* flip udp port */
245         if (netTestCfg.dest_udp_port_config == 0)
246         {
247             printf("dest_udp_port_config is 0, use src port as dest port\n");
248             memcpy(&p_pkt[14+20+2],&p_pkt[14+20],2);
249         }
250         else
251         {
252             dest_udp_port_config = htons(netTestCfg.dest_udp_port_config);
253             printf("flip_and_send_pkt: dest udp port is %d\n", netTestCfg.dest_udp_port_config);
254             //memcpy(&p_pkt[14+20+2],&new_dest_port[0],2);
255             memcpy(&p_pkt[14+20+2],&dest_udp_port_config,2);
256         }
258         memset(&p_pkt[14+20+6],0,2);//0 udp checksum (we will compute on way out)
259     }
261     /*IPSEC case */ 
262     if (flag)
263     {
264         if (netTestCfg.ipsec_mode_tx == IPSEC_MODE_TX_SIDEBAND)
265         //send to crypto for encryption
266         //12 byte auth tag
267         {
268             PKTIO_METADATA_T meta = {PKTIO_META_SB_TX,{0},0};
269             int err;
270             nwalDmTxPayloadInfo_t meta_tx={0};
271             
272             meta.sa_handle = (void*)p_sa_info_tx->tx_tunnel;  //use TX SA APPID
274             memcpy(&meta_tx, &(p_sa_info->tx_payload_info), sizeof(nwalDmTxPayloadInfo_t));
275             meta_tx.appCtxId = (nwal_AppId)p_sa_info_tx;
276             meta_tx.encSize = len - p_sa_info->tx_payload_info.encOffset -p_sa_info->auth_tag_size;
277             meta_tx.authSize = len - meta_tx.authOffset - p_sa_info->auth_tag_size;
278             meta_tx.pAuthIV=NULL;
279             meta_tx.aadSize=0;
280             meta_tx.pAad=NULL;
281             if (p_sa_info->cipherMode ==  NWAL_SA_EALG_AES_CTR)
282             {
283                 memcpy(&p_iv[0], &p_sa_info->key_params->pEncKey[16], 4);
284                 memcpy(&p_iv[4], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
285                 p_iv[12] = 0;
286                 p_iv[13] = 0;
287                 p_iv[14] = 0;
288                 p_iv[15] = 1;
289                 meta_tx.pEncIV = &p_iv[0];
290             }
291             else if ((p_sa_info->cipherMode == NWAL_SA_EALG_AES_GCM) || (p_sa_info->cipherMode == NWAL_SA_EALG_AES_CCM))
292             {
293                 memcpy(&p_iv[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
294                 meta_tx.pEncIV = &p_iv[0];
295                 memcpy(&p_add[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN], 8);
296                 meta_tx.pAad= &p_add[0];
297                 meta_tx.aadSize = 8;
298             }
299             else if (p_sa_info->authMode == NWAL_SA_AALG_GMAC)
300             {
301                 memcpy(&p_iv[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
302                 meta_tx.pAuthIV= &p_iv[0];
303                 memcpy(&p_add[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN], 8);
304                 meta_tx.pAad= &p_add[0];
305                 meta_tx.aadSize = 8;
306             }
307             else if (p_sa_info->cipherMode ==  NWAL_SA_EALG_NULL)
308             {
309                 meta_tx.pEncIV = NULL;
310             }
311             else
312             {
313                 meta_tx.pEncIV = &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN ];
314             }
315             /* post it to netcp sb tx channel*/
316             meta.u.tx_sb_meta=&meta_tx;
318             netapi_pktioSend(netcp_sb_tx_chan,tip,&meta,&err);
319         }
320         else
321         {
322             //INFLOW TX, send pkt directly, asking for IP and UDP checksum offloads AND IPSEC to be applied
323             PKTIO_METADATA_T meta = {PKTIO_META_TX,{0},0};
324             int err;
325             nwalTxPktInfo_t meta_tx={0};
327             meta.sa_handle = (void*)p_sa_info_tx->tx_tunnel;  //use TX SA APPID
329             meta_tx.startOffset = p_sa_info_tx->tx_pkt_info.startOffset;
330             meta_tx.ipOffBytes =p_sa_info_tx->tx_payload_info.encOffset; 
331             meta_tx.l4OffBytes = p_sa_info_tx->tx_pkt_info.l4OffBytes;
332             meta_tx.l4HdrLen = p_sa_info_tx->tx_pkt_info.l4HdrLen;
333             meta_tx.ploadLen = (unsigned) ((p_pkt[meta_tx.l4OffBytes+4]<<8)|p_pkt[meta_tx.l4OffBytes+4+1]) -8 ;
334             meta_tx.saOffBytes=  p_sa_info_tx->tx_pkt_info.saOffBytes;
335             if (pkt_type == netTest_IPSEC_AH_PKT)
336             {
337                 memset(&p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN+netTest_IPSEC_AH_FIXED_HDR_SIZE],0,netTest_IPSEC_AH_FIXED_HDR_SIZE);
338                 meta_tx.txFlag1 = p_sa_info_tx->tx_pkt_info.txFlag1;
339                 meta_tx.saPayloadLen=len-netTest_MAC_HEADER_LEN;   //don't inlcude mac 
340                 meta_tx.saAhMacSize = 12;
341                 meta_tx.saAhIcvOffBytes = netTest_MAC_HEADER_LEN + netTest_IP_HEADER_LEN + netTest_IPSEC_AH_FIXED_HDR_SIZE;
342                 
343                 meta_tx.enetPort = enet_port;
344                  memcpy(&p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN+4],&p_sa_info_tx->spi,4);
345             }
346             else if (pkt_type == netTest_IPSEC_ESP_PKT)
347             {
348                 meta_tx.txFlag1 = p_sa_info_tx->tx_pkt_info.txFlag1;
349                 meta_tx.saPayloadLen=len-netTest_MAC_HEADER_LEN-netTest_IP_HEADER_LEN;   //don't include mac and ip outer header
350                 meta_tx.enetPort = 0;
351                  memcpy(&p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN],&p_sa_info_tx->spi,4);
352             }
353             else
354             {
355                 printf("flip_and_send_pkt: invalid ESP protocol\n");
356                 return;
357             }
359             meta_tx.pseudoHdrChecksum =
360             netTest_utilGetIPv4PsudoChkSum(&p_pkt[meta_tx.ipOffBytes],8+ meta_tx.ploadLen);
363             /* post it to netcp tx channel*/
364             meta.u.tx_meta=&meta_tx;
365             if (stats[coreid].sec_tx<20) netTest_utilDumpDescr((long *) tip, stats[coreid].sec_tx);
367             if ( pkt_type == netTest_IPSEC_ESP_PKT)
368                 netapi_pktioSend(netcp_tx_chan_esp,tip,&meta,&err);
369             else if ( pkt_type == netTest_IPSEC_AH_PKT)
370                  netapi_pktioSend(netcp_tx_chan_ah,tip,&meta,&err);
371             stats[coreid].tx +=1;
372             stats[coreid].sec_tx +=1;
373         }
374     }
375     else  //non ipsec send pkt directly, asking for IP and UDP checksum ofload
376     {
377         PKTIO_METADATA_T meta2 = {PKTIO_META_TX,{0},0};
378         int err;
379         nwalTxPktInfo_t meta_tx2={0};
380         meta2.sa_handle=nwal_HANDLE_INVALID;
381         meta_tx2.txFlag1 = (NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID );
382         meta_tx2.startOffset = 0;
383         meta_tx2.ipOffBytes = netTest_MAC_HEADER_LEN;
384         meta_tx2.l4OffBytes = netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN;
385         meta_tx2.l4HdrLen = netTest_UDP_HEADER_LEN;
386         meta_tx2.ploadLen = (unsigned) ((p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN+4]<<8)|
387                                         p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN+4+1]) -8 ;
388         meta_tx2.pseudoHdrChecksum =
389         netTest_utilGetIPv4PsudoChkSum(&p_pkt[netTest_MAC_HEADER_LEN],8+ meta_tx2.ploadLen);
391         /* post it to netcp tx channel*/
392         meta2.u.tx_meta=&meta_tx2;
393         printf("flip_and_send_pkt: non-ipsec packet received\n");
394         netapi_pktioSend(netcp_tx_chan_no_crypto,tip,&meta2,&err);
395         stats[coreid].tx +=1;
396     }
400 /**********************************************************************
401  * FUNCTION PURPOSE:  Sideband Accelerator Callback PKT RECEIVE HANDLER
402  **********************************************************************
403  * DESCRIPTION:   Sideband Accelerator Callback PKT RECEIVE HANDLER
404  *                Handles Decrypt and Encrypt operation callbacks
405  **********************************************************************/
406 void recv_sb_cb(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
407                          PKTIO_METADATA_T meta[], int n_pkts,
408                          uint64_t ts )
410     int i;
411     int len;
412     int p;
413     netTestHead_T * p_res;
414     Ti_Pkt * tip;
415     unsigned int templen;
416     int err;
417     char * p_pkt;
418     netTestHead_T * p_head;
419     netTestHead_T temp_head;
420     int tag_cmp=0;
421     unsigned int hash[4];
422     uint8_t *p_spi;
423     netTestSA_t *p_sa_info;
425 #ifdef netTest_MULTI_THREAD
426     int coreid=Osal_nwalGetProcId();  //who we are(thread local)
427 #else
428     int coreid=0;
429 #endif
430     //nwal_AppId time;
431     unsigned long time, delta_time;
432     /* loop over received pkts */
433     for(i=0;i<n_pkts;i++)
434    {
435         tip = p_recv[i];
436         Pktlib_getDataBuffer(tip,(uint8_t**)&p_pkt,&templen);//ignore templen
437         len = Pktlib_getPacketLen(tip);//real length
439         /*p_sa_info is for rx context */
440         p_sa_info = (netTestSA_t*)meta[i].u.rx_sb_meta->appCtxId;
441         if (p_sa_info == NULL)
442         {
443             printf("recv_sb_cb(): trie_lookup failed\n");
444             continue;
445         }
447         //is this a decrypt (rx_tunnel) complete
448         if ((int)meta[i].u.rx_sb_meta->appId == p_sa_info->rx_tunnel)
449         {
450             //time = hplib_mUtilGetPmuCCNT();
451             //delta_time = time -(unsigned long) meta[i].u.rx_sb_meta->appCtxId;
452             stats[coreid].total_decrypt_time += delta_time;
453             stats[coreid].sb_rx+=1;
454             //copy hash out of meta data (for some reason it needs endian conversion)
455             hash[0]= netTest_utilHtonl( meta[i].u.rx_sb_meta->pAuthTag[0]);
456             hash[1]= netTest_utilHtonl( meta[i].u.rx_sb_meta->pAuthTag[1]);
457             hash[2]= netTest_utilHtonl( meta[i].u.rx_sb_meta->pAuthTag[2]);
458             hash[3]= netTest_utilHtonl( meta[i].u.rx_sb_meta->pAuthTag[3]);
459             if(stats[coreid].sb_rx<=16)
460             {
461                 char *tp = (char *) &hash[0];
462                 //netTest_utilDumpHeader((long*)p_pkt, stats[coreid].sb_rx, (int)meta[i].u.rx_sb_meta->appId,0);
463             }
464             tag_cmp = memcmp(&p_pkt[len-p_sa_info->auth_tag_size],(char*) &hash[0],p_sa_info->auth_tag_size); //todo, really use meta->authTagLen
465             stats[coreid].n_auth_ok += !(tag_cmp);
466             flip_and_send_pkt(tip, p_pkt, len,1, 0);  //flip packet to echo back and send
467         }
468         //this is an encrypt (tx tunnel) complete
469         else if((int)meta[i].u.rx_sb_meta->appId== p_sa_info->tx_tunnel )
470         {
471             hash[0]= netTest_utilHtonl( meta[i].u.rx_sb_meta->pAuthTag[0]);
472             hash[1]= netTest_utilHtonl( meta[i].u.rx_sb_meta->pAuthTag[1]);
473             hash[2]= netTest_utilHtonl( meta[i].u.rx_sb_meta->pAuthTag[2]);
474             hash[3]= netTest_utilHtonl( meta[i].u.rx_sb_meta->pAuthTag[3]);
475             stats[coreid].sb_tx+=1;
476             if(stats[coreid].sb_tx<=16)
477             {
478                 //netTest_utilDumpHeader((long*)p_pkt, stats[coreid].sb_tx, (int)meta[i].u.rx_sb_meta->appId,0);
479             }
480             //put the computed tag in the packet
481              memcpy(&p_pkt[len-p_sa_info->auth_tag_size],(char*)&hash[0],p_sa_info->auth_tag_size); //todo, really use meta->authTagLen
482             {
483                 PKTIO_METADATA_T meta2 = {PKTIO_META_TX,{0},0};
484                 nwalTxPktInfo_t meta_tx={0};
485                 // now send directly 
486                 meta2.sa_handle=nwal_HANDLE_INVALID;
487                 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
488                 meta_tx.startOffset = 0;
489                 meta_tx.ipOffBytes = netTest_MAC_HEADER_LEN;
490                 meta_tx.l4OffBytes = 0;
491                 meta_tx.l4HdrLen = 0;
492                 meta_tx.ploadLen = 0;
493                 time = hplib_mUtilGetPmuCCNT();
494                 delta_time = time -(unsigned long) meta[i].u.rx_sb_meta->appCtxId;
495                 stats[coreid].total_encrypt_time += delta_time;
497                 /* post it to netcp tx channel*/
498                 meta2.u.tx_meta=&meta_tx;
499                 netapi_pktioSend(netcp_tx_chan_esp,tip,&meta2,&err);
500                 hplib_cacheWbInv(p_pkt,len);
501                 stats[coreid].tx +=1;
502             }
503         }
504         else printf("netapi recv_sb_cb: unknown appiD %x \n",meta[i].u.rx_sb_meta->appId );
505     }
508 /**********************************************************************
509  * FUNCTION PURPOSE:  Packet receive Callback
510  *
511  **********************************************************************
512  * DESCRIPTION:   packet Receive callback
513  **********************************************************************/
514 void recv_cb(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
515                          PKTIO_METADATA_T meta[], int n_pkts,
516                          uint64_t ts )
518     int i;
519     int len;
520     int p;
521     netTestHead_T * p_res;
522     Ti_Pkt * tip;
523     unsigned int templen;
524     int err = 0;
525     char * p_pkt;
526     netTestHead_T * p_head;
527     netTestHead_T temp_head;
528     netTestSA_t *p_sa_info;
529     uint8_t *p_spi;
530     uint8_t p_iv[16];
531     uint8_t p_add[8];
532     uint8_t p_add1[1500];
533     int16_t       retVal;
535     nwalGlobCxtInfo_t   nwalGlobCxt;
536     nwalLocCxtInfo_t    nwalLocCxt;
538     Cppi_HostDesc*          pPloadDesc;
539     int ifno;
540     uint16_t enet_port = 0;
542 #ifdef netTest_MULTI_THREAD
543     int coreid=Osal_nwalGetProcId();  //who we are(thread local)
544     //int coreid = our_core;
545 #else
546     int coreid=0;
547 #endif
548     p_head=&temp_head;
551     /* loop over received pkts */
552     for(i=0;i<n_pkts;i++)
553     {
554         ifno = ((unsigned int)meta[i].u.rx_meta->appId)&0xff;
555         
556         enet_port = meta[i].u.rx_meta->enetPort;
557         tip = p_recv[i];
559         Pktlib_getDataBuffer(tip,(uint8_t**)&p_pkt,&templen);/*ignore templen */
560         len = Pktlib_getPacketLen(tip)-4;   /*real length, subtract mac trailer */
561         Cppi_setData (Cppi_DescType_HOST, (Cppi_Desc *) tip, p_pkt,len);
562         Pktlib_setPacketLen(tip,len);
564         if(((unsigned int)meta[i].u.rx_meta->appId) == expPkt_appid)
565         {
566             netapi_Log("recv_cb: received exception packet\n");
567             Pktlib_freePacket(tip);
568             if(((unsigned int)meta[i].u.rx_meta->rxFlag1  & NWAL_RX_IP_FRAGMENT_PKT) ==
569                                              NWAL_RX_IP_FRAGMENT_PKT)
570             {
571                 stats[coreid].exceptionPktsFrag+=1;
572             }
573             else
574             {
575                 stats[coreid].exceptionPktsOther+=1;
576             }
577             continue;
578         }
579         //debug: validate descriptor */
580         if(Pktlib_getNextPacket(tip) != 0) 
581         {
582             printf(" rcv_cb, nexpkt != NULL");
583         }
585         if(coreid<TUNE_NETAPI_NUM_CORES)
586             stats[coreid].rx+=1;
587         if (ifno < TUNE_NETAPI_MAX_NUM_MAC)
588             stats[coreid].if_rx[ifno]+=1;
591 #ifdef DEBUG_DESC
592         if (stats[coreid].rx<16)
593         {
594             netapi_Log(">rx dmp.."); 
595             netTest_utilDumpDescr((long *) tip, stats[coreid].rx);
596         }
597         else if (stats[coreid].rx>99) 
598         {
599             netapi_Log(">rx dmp.."); 
600             netTest_utilDumpDescr((long *) tip,stats[coreid].rx);
601         }
602 #endif
603 #if 0
604         if(stats[coreid].rx<=16)
605         {
606             netTest_utilDumpHeader((long*)p_pkt,stats[coreid].rx, (int)meta[i].u.rx_meta->appId,meta[i].u.rx_meta->rxFlag1);
607               netTest_utilDumpBuffer((long*)p_pkt,len);
608         }
609 #endif
610         /* check header */
611         memcpy(p_head,&p_pkt[14],sizeof(netTestHead_T));
613         /* check for IPSEC ESP or AH packet, 0x32 is ESP tunnel mode, 0x33 is AH tunnel mode*/
614         if (((p_head->ip[2]&0x0000ff00)==0x00003200) || ((p_head->ip[2]&0x0000ff00)==0x00003300))
615         {
616             if (!netTest_utilCheckHeader(p_head,&meta[i]))
617             {
618                 stats[coreid].n_bad+=1;Pktlib_freePacket(tip); 
619                 continue;
620             }
622             //process IP SEC PACKET
623             if (netTestCfg.ipsec_mode_rx == IPSEC_MODE_RX_SIDEBAND)
624             {
625                 p_spi = &(p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN]);
626                 p_sa_info = (netTestSA_t *) trie_lookup(p_trie_sa_rx, (char *)p_spi ,4);
627                 if (p_sa_info == NULL)
628                 {
629                     printf("recv_cb(): trie_lookup() failed\n");
630                     continue;
631                 }
633                 //ship to crypto for decrypt!!
634                 //12 byte auth tag
635                 PKTIO_METADATA_T meta2 = {PKTIO_META_SB_TX,{0},0};
636                 nwalDmTxPayloadInfo_t meta_tx={0};
638                 meta2.sa_handle = (void*) p_sa_info->rx_tunnel;
640                 memcpy(&meta_tx, &(p_sa_info->tx_payload_info), sizeof(nwalDmTxPayloadInfo_t));
642                 meta_tx.encSize = len - p_sa_info->tx_payload_info.encOffset -p_sa_info->auth_tag_size;
643                 meta_tx.authSize = len - meta_tx.authOffset - p_sa_info->auth_tag_size;
645                 if (p_sa_info->cipherMode == NWAL_SA_EALG_AES_CTR)
646                 {
647                     memcpy(&p_iv[0], &p_sa_info->key_params->pEncKey[16], 4);
648                     memcpy(&p_iv[4], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
649                     p_iv[12] = 0;
650                     p_iv[13] = 0;
651                     p_iv[14] = 0;
652                     p_iv[15] = 1;
653                     meta_tx.pEncIV = &p_iv[0];
654                  
655                 }
656                 else if ((p_sa_info->cipherMode == NWAL_SA_EALG_AES_GCM) ||
657                             (p_sa_info->cipherMode == NWAL_SA_EALG_AES_CCM))
658                 {
659                         memcpy(&p_iv[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
660                         meta_tx.pEncIV = &p_iv[0];
661                         /* aad is the ESP header which is 8 bytes */
662                         memcpy(&p_add[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN], 8);
663                         meta_tx.pAad= &p_add[0];
664                         meta_tx.aadSize = 8;
665                 }
666                 else if (p_sa_info->authMode == NWAL_SA_AALG_GMAC)
667                 {
668                     memcpy(&p_iv[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
669                         meta_tx.pAuthIV= &p_iv[0];
670                         /* aad is the ESP header which is 8 bytes */
671                         memcpy(&p_add[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN], 8);
672                         meta_tx.pAad= &p_add[0];
673                         meta_tx.aadSize = 8;
674                 }
675                 else if (p_sa_info->cipherMode ==  NWAL_SA_EALG_NULL)
676                 {
677                     meta_tx.pEncIV = NULL;
678                 }
679                 else
680                 {
681                     meta_tx.pEncIV = &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN ];
682                 }
683                
684                 meta_tx.appCtxId = (nwal_AppId)p_sa_info;
685                 //printf("recv_cb appCtxId: %lu\n", meta_tx.appCtxId);
687                 /* post it to netcp sb tx channel*/
688             meta2.u.tx_sb_meta=&meta_tx;
690                 netapi_pktioSend(netcp_sb_tx_chan,tip,&meta2,&err);
691                 continue;
692             }
693             else
694             {
695                 //inflow mode.  flip and send
696                 flip_and_send_pkt(tip,p_pkt,len,1, enet_port);
697             }
698         }
699         else if ((p_head->ip[2]&0x0000ff00)!=0x00001100)
700         {
701             stats[coreid].n_new+=1;Pktlib_freePacket(tip); continue;
702         }
703         else  //non ipsec
704         {
705             if (!netTest_utilCheckHeader(p_head,&meta[i]))
706             {
707                 stats[coreid].n_bad+=1;Pktlib_freePacket(tip); 
708                 continue;
709             }
710             //just flip and send
711             flip_and_send_pkt(tip,p_pkt,len,0, enet_port);
712         }
713     }
716 /* Templates to build command labels at startup up time, required by open_pktio_tx_channels() */
717 nwalTxPktInfo_t txPktInfoESP = 
719     NULL,                                                                                               /* p_pkt */
720     NWAL_TX_FLAG1_DO_IPSEC_ESP_CRYPTO| NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID,      /* txFlags */
721     0,                                                                                                  /* lpbackPass */
722     0,                                                                                                  /* enetport */
723     0,                                                                                                  /* msuSize */
724     0,                                                                                                   /* startOffset */
725     netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN,                                                    /* saOffBytes */
726     0,                                                                                                  /* saPayLoadLen */
727     0               ,                                                                                    /* saAhIcvOffBytes */
728     0,                                                                                                 /* saAhMacSize */
729     0,                                                                                                  /* etherLenOffBytes */
730     0,                                                                                                  /* ipOffBytes */
731     0,                                                                                                  /* l4OffBytes */
732     netTest_UDP_HEADER_LEN,                                                                             /* l4HdrLen */
733     0,                                                                                                  /* pseudoHdrChecksum */
734     0                                                                                                   /* pLoadLen */
735 };
738 nwalTxPktInfo_t txPktInfoAH = 
740     NULL,                                                                                               /* p_pkt */
741     NWAL_TX_FLAG1_DO_IPSEC_AH_CRYPTO| NWAL_TX_FLAG1_DO_UDP_CHKSUM | NWAL_TX_FLAG1_META_DATA_VALID,      /* txFlags */
742     0,                                                                                                  /* lpbackPass */
743     0,                                                                                                  /* enetport */
744     0,                                                                                                  /* msuSize */
745     0,                                                                                                   /* startOffset */
746     netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN,                                                    /* saOffBytes */
747     0,                                                                                                  /* saPayLoadLen */
748     netTest_MAC_HEADER_LEN + netTest_IP_HEADER_LEN + netTest_IPSEC_AH_FIXED_HDR_SIZE,                    /* saAhIcvOffBytes */
749     12,                                                                                                 /* saAhMacSize */
750     0,                                                                                                  /* etherLenOffBytes */
751     0,                                             /* ipOffBytes */
752     0,                                                                                                  /* l4OffBytes */
753     netTest_UDP_HEADER_LEN,                                                                            /* l4HdrLen */
754     0,                                                                                                  /* pseudoHdrChecksum */
755     0                                                                                                   /* pLoadLen */
756 };
758 nwalTxPktInfo_t txPktInfoNoCrypto = 
760     NULL,                                                                                               /* p_pkt */
761     NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID,      /* txFlags */
762     0,                                                                                                  /* lpbackPass */
763     0,                                                                                                  /* enetport */
764     0,                                                                                                  /* msuSize */
765     0,                                                                                                   /* startOffset */
766     0,                                                    /* saOffBytes */
767     0,                                                                                                  /* saPayLoadLen */
768     0               ,                                                                                    /* saAhIcvOffBytes */
769     0,                                                                                                 /* saAhMacSize */
770     0,                                                                                                  /* etherLenOffBytes */
771     0,                                                                                                  /* ipOffBytes */
772     netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN,                                        /* l4OffBytes */
773     netTest_UDP_HEADER_LEN,                                                             /* l4HdrLen */
774     0,                                                                         /* pseudoHdrChecksum */
775     0                                                                                                   /* pLoadLen */
776 };
779 void close_pktio_channels(void)
781     int err;
782     netapi_pktioClose(netcp_tx_chan_esp ,&err);
783     netapi_pktioClose(netcp_tx_chan_ah ,&err);
784     netapi_pktioClose(netcp_sb_tx_chan ,&err);
785     netapi_pktioClose(netcp_tx_chan_no_crypto,&err);
788 void open_pktio_tx_channels(void)
790     int err;
791     /* open netcp default  TX for ESP packets */
792     netcp_tx_chan_esp= netapi_pktioOpen(netapi_handle, NETCP_TX, NULL, &netcp_tx_cfg,  &err);
793     if (!netcp_tx_chan_esp)
794     {
795         printf("pktio open TX failed err=%d\n",err);
796         exit(1);
797     }
798     else
799     {
800         if(netTestCfg.ipsec_mode_tx == IPSEC_MODE_TX_INFLOW)
801         {
802             PKTIO_CONTROL_T control;
803             control.op = PKTIO_UPDATE_FAST_PATH;
804             PKTIO_CFG_T cfg;
805             cfg.fast_path_cfg.fp_send_option = PKTIO_FP_ESP_L4CKSUM_PORT;
806             cfg.fast_path_cfg.txPktInfo= &txPktInfoESP;
807             netapi_pktioControl(netcp_tx_chan_esp, NULL, &cfg, &control, &err);
808         }
809     }
811     /*/* open netcp default  TX for AH packets */
812     netcp_tx_chan_ah= netapi_pktioOpen(netapi_handle, NETCP_TX, NULL, &netcp_tx_cfg,  &err);
813     if (!netcp_tx_chan_ah)
814     {
815         printf("pktio open TX failed err=%d\n",err);
816         exit(1);
817     }
818     else
819     {
820         if(netTestCfg.ipsec_mode_tx == IPSEC_MODE_TX_INFLOW)
821         {
822             PKTIO_CONTROL_T control;
823             control.op = PKTIO_UPDATE_FAST_PATH;
824             PKTIO_CFG_T cfg;
825             cfg.fast_path_cfg.fp_send_option = PKTIO_FP_AH_L4CKSUM_PORT;
826             cfg.fast_path_cfg.txPktInfo= &txPktInfoAH;
827             netapi_pktioControl(netcp_tx_chan_ah, NULL, &cfg, &control, &err);
828         }
829     }
831     /* open netcp default  TX channels for non-Crypto packets */
832     netcp_tx_chan_no_crypto= netapi_pktioOpen(netapi_handle, NETCP_TX, NULL, &netcp_tx_cfg,  &err);
833     if (!netcp_tx_chan_no_crypto)
834     {
835         printf("pktio open TX failed err=%d\n",err);
836         exit(1);
837     }
838     else
839     {
840         if(netTestCfg.ipsec_mode_tx == IPSEC_MODE_TX_INFLOW)
841         {
842             PKTIO_CONTROL_T control;
843             control.op = PKTIO_UPDATE_FAST_PATH;
844             PKTIO_CFG_T cfg;
845             cfg.fast_path_cfg.fp_send_option = PKTIO_FP_L4CKSUM_PORT;
846             cfg.fast_path_cfg.txPktInfo= &txPktInfoNoCrypto;
847             netapi_pktioControl(netcp_tx_chan_no_crypto, NULL, &cfg, &control, &err);
848         }
849     }
851     /* open netcp default  TX channels for SB crypto */
852     netcp_sb_tx_chan= netapi_pktioOpen(netapi_handle, NETCP_SB_TX, NULL, &netcp_sb_tx_cfg,  &err);
853     if (!netcp_sb_tx_chan)
854     {
855         printf("pktio open SB TX failed err=%d\n",err);
856         exit(1);
857     }
860 #ifdef netTest_DSP_FASTPATH
861 void setup_netTestDSPFastPath(NETAPI_T handle, uint32_t thread_num)
863     int i;
864     int err = 0;
865     PKTIO_CFG_T dsp_pktio_cfg;
866     NETCP_CFG_CLASSIFIER_T dsp_classi;
867     NETCP_CFG_ROUTE_T dsp_route;
869     memset(&dsp_pktio_cfg, 0, sizeof (PKTIO_CFG_T));
870     memset(&dsp_classi, 0, sizeof (NETCP_CFG_CLASSIFIER_T));
871     memset(&dsp_route, 0, sizeof (NETCP_CFG_ROUTE_T));
872     char dsp_name[32];
873     //for (i = 0; i < CPU_NUM_REM_FAST_PATH_CORES; i++)
874     for (i = 0; i < 1; i++)
875     {
876         sprintf(&dsp_name[0],"%s%d","dsp_chan", i);
877         printf("netTest_utilCreateInterfaces: %s\n",&dsp_name[0]);
879         dsp_pktio_cfg.flags1 = PKTIO_RX;
880         dsp_pktio_cfg.flags2 = PKTIO_GLOBAL | PKTIO_PKT;
881         dsp_pktio_cfg.qnum = TEST_NWAL_BASE_REM_FP_RX_PKT_QUEUE + i;
882         dsp_pktio_cfg.max_n = 8;
884         /* pktio channels created here will NOT be POLLED by net_test arm application */
885         dsp_pktio_channels[i] = netapi_pktioCreate(handle,
886                                                &dsp_name[0],
887                                                (PKTIO_CB)recv_cb,
888                                                &dsp_pktio_cfg,
889                                                &err);
890         if (dsp_pktio_channels[i])
891         {
892             printf("setup_netTestDSPFastPath: sucess for core %d\n", i);
893         }
894         else
895         {
896             printf("setup_netTestDSPFastPath: failed for core %d\n", i);
897         }
899         dsp_classi.classType =NETCP_CFG_CLASS_TYPE_L4;
900         dsp_classi.u.c_l4.iface = netTestCfg.dsp_mac;
901         
902         dsp_classi.u.c_l4.ip = ip_rule[netTestCfg.dsp_ip];
903         dsp_classi.u.c_l4.proto = NWAL_APP_PLOAD_PROTO_UDP;
904         dsp_classi.u.c_l4.appProto.udpPort = TEST_NWAL_BASE_REM_FP_UDP_PORT + i;
905         printf("setup_netTestDSPFastPath: iface 0x%x, proto: 0x%x, thread_num %d\n", dsp_classi.u.c_l4.iface, dsp_classi.u.c_l4.proto, thread_num);
908         dsp_route.p_dest_q = dsp_pktio_channels[i];
909        
910         dsp_route.p_flow = (NETCP_CFG_FLOW_T*)NETCP_DEFAULT_FLOW;
911         
912         
913         dsp_classifers[i] = netapi_netcpCfgAddClass(handle, 
914                                 &dsp_classi, 
915                                 (NETCP_CFG_ROUTE_HANDLE_T) &dsp_route, 
916                                 NETCP_CFG_ACTION_TO_SW,
917                                 NULL,
918                                 &err);
921         if (err == NETAPI_ERR_OK)
922         {
923             printf("setup_netTestDSPFastPath: netapi_netcpCfgAddClass sucess for core %d\n", i);
924         }
925         else
926         {
927             printf("setup_netTestDSPFastPath: netapi_netcpCfgAddClass failed for core %d\n", i);
928         }
929     }
932 void teardown_netTestDSPFastPath()
934     int i;
935     int err=0;
937     for (i = 0; i < CPU_NUM_REM_FAST_PATH_CORES; i++)
938     {
939         netapi_netcpCfgDelClass(netapi_handle,
940                                 dsp_classifers[i],
941                                 &err);
942         if (err == NETAPI_ERR_OK)
943         {
944             printf("teardown_netTestDSPFastPath: netapi_netcpCfgDelClass sucess for core %d\n", i);
945         }
946         else
947         {
948             printf("teardown_netTestDSPFastPath: netapi_netcpCfgDelClass failed for core %d\n", i);
949         }
951         netapi_pktioDelete(dsp_pktio_channels[i],
952                            &err);
953         if (err == NETAPI_ERR_OK)
954         {
955             printf("teardown_netTestDSPFastPath: netapi_pktioDelete sucess for core %d\n", i);
956         }
957         else
958         {
959             printf("teardown_netTestDSPFastPath: netapi_pktioDelete failed for core %d\n", i);
960         }
961     }
963 #endif
966 #ifdef netTest_MULTI_THREAD
967 NETAPI_T worker_nh[TUNE_NETAPI_NUM_CORES];
969 void slow_path_thread(uint32_t thread_num)
971     int err, i;;
973     PKTIO_HANDLE_T *rx_chan;
974     PKTIO_HANDLE_T *sb_rx_chan;
976     printf("slow_path_thread, mypid: %d, core_id %d\n", gettid(), thread_num);
978     CPU_ZERO( &cpu_set);
979     printf("slow_path_thread: settting up for thread number %d\n", thread_num);
980 #ifdef CORTEX_A15
981     for (i = netTestCfg.sp_proc_start[thread_num]; i <= netTestCfg.sp_proc_end[thread_num];i++)
982     {
983         printf("slow_path_thread: setting cpu %d to cpu_set\n", i);
984         CPU_SET( i, &cpu_set);
985     }
986     hplib_utilSetupCore(thread_num, &cpu_set);
987 #else
988     for (i = netTestCfg.sp_proc_start[thread_num]; i <= netTestCfg.sp_proc_end[thread_num];i++)
989     {
990         printf("slow_path_thread: setting cpu %d to cpu_set\n", i);
991         CPU_SET( i, &cpu_set);
992     }
993     hplib_utilSetupCore(thread_num, &cpu_set);
994 #endif
995     worker_nh[thread_num]=netapi_init(NETAPI_CORE_MASTER,NULL);
997     netapi_setCookie(worker_nh[thread_num],(void*)(thread_num | NET_TEST_SP_THREAD_MASK));
999     scheduler[thread_num] =netapi_schedOpen(worker_nh[thread_num],&our_sched_cfg, &err);
1000     if (!scheduler[thread_num]) 
1001     {
1002         printf("sched create failed for core%d\n",thread_num);
1003         exit(1);
1004     }
1005     scheduler[thread_num]->config.yield = TRUE;
1006     scheduler[thread_num]->config.pollGarbageQ = TRUE;
1007     scheduler[thread_num]->config.pollCtrlQ = TRUE;
1009     /* Entry point to scheduler */
1010     netapi_schedRun(scheduler[thread_num], &err);
1011     printf(">net_test: core %d worker thread done\n",thread_num);
1013     netapi_shutdown(worker_nh[thread_num]);
1016 void fast_path_thread(uint32_t thread_num)
1018     int err, i;
1019     PKTIO_HANDLE_T *rx_chan;
1020     PKTIO_HANDLE_T *sb_rx_chan;
1022     CPU_ZERO( &cpu_set);
1023     printf("fast_path_thread: settting up for thread number %d\n", thread_num);
1024 #ifdef CORTEX_A15
1025     for (i = netTestCfg.fp_proc_start[thread_num]; i <= netTestCfg.fp_proc_end[thread_num];i++)
1026     {
1027         printf("fast_path_thread: setting cpu %d to cpu_set\n", i);
1028         CPU_SET( i, &cpu_set);
1029     }
1030     hplib_utilSetupCore(thread_num, &cpu_set);
1031 #else
1032     for (i = netTestCfg.fp_proc_start[thread_num]; i <= netTestCfg.fp_proc_end[thread_num];i++)
1033     {
1034         printf("fast_path_thread: setting cpu %d to cpu_set\n", i);
1035         CPU_SET( i, &cpu_set);
1036     }
1037     hplib_utilSetupCore(thread_num, &cpu_set);
1038 #endif
1039     worker_nh[thread_num]=netapi_init(NETAPI_CORE_MASTER,NULL);
1041    /* open netcp default RX channels*/
1042     rx_chan = netapi_pktioOpen(worker_nh[thread_num], NETCP_RX, (PKTIO_CB) recv_cb, &netcp_rx_cfg,  &err);
1044     /* create a pktio channel for specially classified pkts */
1045     /* open netcp default tx, rx queues for sideband crypto */
1046      //sb_tx_chan = netapi_pktioOpen(worker_nh[thread_num], NETCP_SB_TX, NULL, &netcp_sb_tx_cfg,  &err);
1047      sb_rx_chan = netapi_pktioOpen(worker_nh[thread_num], NETCP_SB_RX, (PKTIO_CB) recv_sb_cb, &netcp_sb_rx_cfg,  &err);
1049 #ifdef netTest_DSP_FASTPATH
1050     setup_netTestDSPFastPath(netapi_handle, thread_num);
1051 #endif
1052     
1053     netapi_setCookie(worker_nh[thread_num],(void*)thread_num);
1054     
1055     scheduler[thread_num] =netapi_schedOpen(worker_nh[thread_num],&our_sched_cfg, &err);
1056     if (!scheduler[thread_num]) 
1057         {
1058         printf("sched create failed for core%d\n",thread_num); 
1059         exit(1);
1060     }
1062  
1063     scheduler[thread_num]->config.yield = FALSE;
1064     scheduler[thread_num]->config.pollGarbageQ = FALSE;
1065     scheduler[thread_num]->config.pollCtrlQ = FALSE;
1066      //sleep(100000);
1067    /* Entry point to scheduler */
1068      netapi_schedRun(scheduler[thread_num], &err);
1069     printf(">net_test: core %d worker thread done\n",thread_num);
1071     netapi_pktioClose(rx_chan, &err);
1073     netapi_pktioClose(sb_rx_chan, &err);
1074     netapi_shutdown(worker_nh[thread_num]);
1077 #endif
1078 /***************************************
1079  ********** test driver*****************
1080  ***************************************/
1081 int main(int argc, char **argv)
1083     int err,i;
1084     Pktlib_HeapCfg      heapCfg;
1085     int32_t             errCode;
1086     Pktlib_HeapIfTable*  pPktifTable;
1087     FILE * fpr = NULL;
1089      /* install signal handler for ^c */
1090     signal(SIGINT,netTest_utilMySig);
1092     if (argc == 2)
1093     {
1094         printf("main: filename1 %s\n", argv[1]);
1095         fpr = fopen(argv[1], "r");
1096     }
1097     else
1098     {
1099         fpr = fopen(input_file_name, "r");
1100     }
1101     if (fpr == NULL)
1102     {
1103         exit(1);
1104     }
1105     else
1106     {
1107         memset(&config_file, 0, sizeof(netTestConfigFile_t));
1108         memset(&netTestCfg, 0, sizeof(netTestConfig_t));
1109         
1110         netTest_utilProcessConfigFile(fpr,&config_file);
1111 #if 1
1112         netTest_utilParseMac(&config_file);
1114         /* parse slow path/fast path thread configuration parameters */
1115         netTest_utilParseThreadParams(&config_file);
1117         netTest_utilParseIP(&config_file);
1119         netTest_utilParseIpsecMode(&config_file);
1121         /* DSP mac processing */
1122         parse_dsp_mac(&config_file.dsp_mac[0]);
1124        /* DSP IP processing */
1125         parse_dsp_ip(&config_file.dsp_ip[0]);
1127         /* IPSEC interface number processing */
1128         parse_simple_param_u32((char*)&config_file.ipsec_if_no[0], &netTestCfg.ipsec_if_no);
1130         netTest_utilParseSA(&config_file);
1132         parse_simple_param_u32(&config_file.dest_udp_port_config, &netTestCfg.dest_udp_port_config);
1133 #endif
1134     }
1136     memset(&sa_info, 0, sizeof(sa_info));
1139 #ifdef netTest_MULTI_THREAD
1140     /* assign main net_test thread to run on core 0 */
1141     CPU_ZERO( &cpu_set);
1142     CPU_SET( 0, &cpu_set);
1143     hplib_utilSetupCore(0, &cpu_set);
1144 #endif
1146     /* create netapi */
1147     netapi_handle = netapi_init(NETAPI_SYS_MASTER, &our_netapi_default_cfg);
1149     /* configure expection packet handling with netapi */
1150     netapi_netcpCfgExceptions(netapi_handle,
1151                               NETCP_CFG_ALL_EXCEPTIONS,
1152                               NETCP_CFG_ACTION_DISCARD, 
1153                               (NETCP_CFG_ROUTE_HANDLE_T) NULL);
1154     expPkt_appid = netapi_netcpCfgExceptions(netapi_handle, 
1155                                              7,
1156                                              NETCP_CFG_ACTION_TO_SW,
1157                                              (NETCP_CFG_ROUTE_HANDLE_T) NULL);
1159     /* open the main heap */
1160     ourHeap = Pktlib_findHeapByName("netapi");
1161     if (!ourHeap)
1162     {
1163         printf("Pktlib_findHeapByName()  fail\n");
1164         exit(1);
1165     }
1167     open_pktio_tx_channels();
1169     printf("net_test: %d bytes left in our CMA area\n", netapi_getBufMemRemainder());
1170     /* create scheduler instance */
1171     our_sched =netapi_schedOpen(netapi_handle,&our_sched_cfg, &err);
1172     if (!our_sched) {printf("sched create failed\n"); exit(1);}
1175     /*create net_test MAC interfaces, attach IP to created MAC interfaces */
1176     netTest_utilCreateInterfaces(netTestCfg.num_macs, netTestCfg.num_ips);
1178     /* lookup Database for SA context, this is used by packet processing routines to get RX and TX SA information*/
1179     p_trie_sa_rx = trie_new();
1180     p_trie_sa_tx = trie_new();
1181     if (!p_trie_sa_rx || !p_trie_sa_tx)
1182         {printf("trie alloc for SA  failed\n"); exit(1);}
1184 #ifdef netTest_DSP_FASTPATH
1185     //setup_netTestDSPFastPath();
1186 #endif
1188     /* Create RX SA's, RX Policy and TX SA's, all SA configuration parameters are read from net_test_config.txt file */
1189     netTest_utilCreateSecAssoc();
1191 #ifdef netTest_MULTI_THREAD
1194     nwalGlobCxtInfo_t nwalGlobCxt;
1195     nwalLocCxtInfo_t nwalLocCxt;
1196     int count;
1197     NETAPI_HANDLE_T * n = (NETAPI_HANDLE_T *) netapi_handle;
1199     nwal_getGlobCxtInfo(((NETAPI_GLOBAL_T*) (n->global))->nwal_context.nwalInstHandle,&nwalGlobCxt);
1200     //printf("0x%x, 0x%x, 0x%x, 0x%x, 0x%x\n", Info.defFlowQ, Info.rxDefPktQ, Info.rxPaSaFlowId, Info.rxSaPaFlowId, Info.passCppiHandle);
1203     printf("*******NWAL Global Context Info Dump Begin *******\n");
1204     printf("rxPaSaFlowId:%d,rxSaPaFlowId:%d rxDefPktQ:0x%x \n",
1205                        nwalGlobCxt.rxPaSaFlowId,nwalGlobCxt.rxSaPaFlowId,
1206                         nwalGlobCxt.rxDefPktQ);
1207     printf("defFlowQ:0x%x,passCppiHandle:0x%x extErr:%d \n",
1208                        nwalGlobCxt.defFlowQ,nwalGlobCxt.passCppiHandle,
1209                        nwalGlobCxt.extErr);
1210     for(count=0;count < nwalGlobCxt.numPaPDSPs;count++)
1211     {
1212         printf("NetCP PASS PDSP - %d Version:0x%x \n",
1213                       count,nwalGlobCxt.pdspVer[count]);
1214     }
1215     printf("*******NWAL Global Context Info Dump End *******\n\n");
1218     nwal_getLocCxtInfo(((NETAPI_GLOBAL_T*) (n->global))->nwal_context.nwalInstHandle,&nwalLocCxt);
1219     printf("*******NWAL Local Context Info Dump Begin *******\n");
1220     printf("rxCtlQ:%d,rxL4PktQ:%d \n",
1221                         nwalLocCxt.rxCtlQ,
1222                         nwalLocCxt.rxL4PktQ);
1223     printf("rxPktFlowId:0x%x,rxCtlFlowId:0x%x extErr:%d \n",
1224                        nwalLocCxt.rxPktFlowId
1225                        ,nwalLocCxt.rxCtlFlowId,
1226                        nwalLocCxt.extErr);
1227     
1228     printf("*******NWAL Local Context Info Dump End *******\n\n");
1234 #if 1
1235 typedef struct  {
1236     uint16_t                numPendPAReq;/**< Number of pending PA requests for
1237                                            *  process
1238                                            */
1239     NWAL_queueHnd           rxCtlQ;      /**< Response Queue for receiving
1240                                            *  control response
1241                                            */
1242     NWAL_queueHnd           rxL4PktQ;    /**< Default Queue for receiving L4
1243                                            *  Packets
1244                                            */
1245     NWAL_queueHnd           rxSbSaQ;     /**< Packet Queue to receive response
1246                                           * for all data mode SA related
1247                                           * responses
1248                                           */
1249     uint16_t                extErr;      /**< Extended Error details from NetCP
1250                                            */
1251     int16_t                 rxPktFlowId; /**< Default Flow Handle for packets
1252                                            *  from NetCP to host
1253                                            */
1254     int16_t                 rxCtlFlowId; /**< Default Flow Handle for control
1255                                            *  response from NetCP to host
1256                                            */
1257 } nwalLocCxtInfo_t;
1258 #endif
1260     char c;
1261     /* create and set affinity of slow path and fast path threads to
1262     * specific CPU cores as specified in the net_test_config.txt file */
1263     netTest_utilCreateSpFpThreads(netTestCfg.num_sp_threads, 
1264                                   (NET_TEST_FUNC_PTR) slow_path_thread,
1265                                   netTestCfg.num_fp_threads,
1266                                   (NET_TEST_FUNC_PTR) fast_path_thread);
1268         //this thread of execution (main) now just waits on user input
1269         for(;;)
1270         {
1271            printf(">");
1272            c=getchar();
1273            if (c=='q') {QUIT=1;break;}
1274            else if (c=='s') netTest_utilsStatsCb(netapi_handle, &netcp_stats);
1275            else if (c=='h') printf("'q' to quit,  's' for stats, 'h' for help\n");
1276         }
1278         netTest_utilRemoveSpFpThreads(netTestCfg.num_sp_threads, netTestCfg.num_fp_threads);
1281 #else
1282     /*********************************************/
1283     /**************Entry point into scheduler ****/
1284     /*********************************************/
1285     //netTest_utilCreateSecAssoc(netcp_sb_rx_chan, netcp_sb_tx_chan,netcp_tx_chan);
1286     netapi_schedRun(our_sched, &err);
1287 #endif
1289     /* done */
1290     netTest_utilsStatsCb(netapi_handle, NULL);
1293     /* cleanup*/
1294      netTest_utilDeleteSecAssoc();
1296     netTest_utilDeleteInterfaces(netTestCfg.num_macs, netTestCfg.num_ips);
1298     /* close pktio channels we opened via open_pktio_tx_channels() */
1299     close_pktio_channels();
1300 #ifdef netTest_DSP_FASTPATH
1301     teardown_netTestDSPFastPath();
1302 #endif
1303     netapi_shutdown(netapi_handle);
1307 #if 1
1308 /* Stub functions */
1309 Trie * route_init(void)
1312 void route_add(Trie * Pt, unsigned long * Pdest_ipBE, void * Pour_route)
1315 #endif