Update config file paths to point to new location on filesystem
[keystone-rtos/netapi.git] / ti / runtime / netapi / test / net_test_loopback.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 2013
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  *****************************************************************************/
44 #include "netapi.h"
45 #include "net_test_sa_utils.h"
46 #include "net_test_utils.h"
47 #include "net_test_thread_utils.h"
48 #include "ti/drv/nwal/test/fw_rm.h"
49 #include <signal.h>
50 #include <pthread.h>
53 #if defined(DEVICE_K2H)
54 #include <ti/drv/qmss/device/k2h/src/qmss_device.c>
55 #include <ti/drv/cppi/device/k2h/src/cppi_device.c>
56 #elif defined (DEVICE_K2K)
57 #include <ti/drv/qmss/device/k2k/src/qmss_device.c>
58 #include <ti/drv/cppi/device/k2k/src/cppi_device.c>
59 #elif defined (DEVICE_K2L)
60 #include <ti/drv/qmss/device/k2l/src/qmss_device.c>
61 #include <ti/drv/cppi/device/k2l/src/cppi_device.c>
62 #elif defined (DEVICE_K2E)
63 #include <ti/drv/qmss/device/k2e/src/qmss_device.c>
64 #include <ti/drv/cppi/device/k2e/src/cppi_device.c>
65 #else /*Default */
66 #include <ti/drv/qmss/device/k2h/src/qmss_device.c>
67 #include <ti/drv/cppi/device/k2h/src/cppi_device.c>
68 #endif /* Device */
71 extern int QUIT;
72 extern netTestStats_T stats[TUNE_NETAPI_NUM_CORES];
73 extern paSysStats_t netcp_stats;
75 extern Rm_ServiceHandle   *rmClientServiceHandle;
76 hplib_spinLock_T net_test_thread_lock;
79 netTestConfig_t netTestCfg;
80 static netTestConfigFile_t config_file;
81 char    input_file_name[] = "/etc/transportnetlib/test/net_test_config.txt";
82 nwal_RetValue       nwalRetVal;
83 Pktlib_HeapHandle   ourHeap;
85 PKTIO_HANDLE_T *netcp_rx_chan;
86 PKTIO_HANDLE_T *netcp_tx_chan_no_crypto;
87 PKTIO_HANDLE_T *netcp_tx_chan_esp;
88 PKTIO_HANDLE_T *netcp_tx_chan_ah;
89 PKTIO_HANDLE_T *netcp_sb_tx_chan;
90 PKTIO_HANDLE_T *netcp_sb_rx_chan;
92 PKTIO_CFG_T netcp_rx_cfg={PKTIO_RX, PKTIO_NA, PKTIO_NA, 8};
93 PKTIO_CFG_T netcp_rx_cfg2={PKTIO_RX, (PKTIO_GLOBAL|PKTIO_PKT), PKTIO_Q_ANY, 8};
94 PKTIO_CFG_T netcp_tx_cfg={PKTIO_TX, PKTIO_NA, PKTIO_NA, 8};
95 PKTIO_CFG_T netcp_sb_rx_cfg={PKTIO_RX, PKTIO_NA, PKTIO_NA, 8};
96 PKTIO_CFG_T netcp_sb_tx_cfg={PKTIO_TX, PKTIO_NA, PKTIO_NA, 8};
98 NETCP_CFG_IP_T ip_rule[NET_TEST_MAX_IP];
99 NETCP_CFG_MACIF_T mac[NET_TEST_MAX_MAC];
101 #ifdef netTest_DSP_FASTPATH
102 PKTIO_HANDLE_T *dsp_pktio_channels[CPU_NUM_REM_FAST_PATH_CORES];
103 NETCP_CFG_CLASS_T dsp_classifers[CPU_NUM_REM_FAST_PATH_CORES];
104 NETCP_CFG_FLOW_HANDLE_T dsp_flow_handles[CPU_NUM_REM_FAST_PATH_CORES];
105 #endif
106 NETCP_CFG_EXCEPTION_PKT_T expPkt_appid;
108 Trie *p_trie_sa_rx;
109 Trie *p_trie_sa_tx;
112 /*******************************************
113  *************NETAPI OBJECTS***************
114  *****************************************/
115 static NETAPI_CFG_T our_netapi_default_cfg=
117     TUNE_NETAPI_PERM_MEM_SZ,
118     128,  //start of packet offset for hw to place data on rx for default flow
119     TUNE_NETAPI_QM_CONFIG_MAX_DESC_NUM, //max number of descriptors in system
120     TUNE_NETAPI_NUM_GLOBAL_DESC,        //total we will use
121     TUNE_NETAPI_DEFAULT_NUM_BUFFERS,   //#descriptors+buffers in default heap
122     64, //#descriptors w/o buffers in default heap
123     TUNE_NETAPI_DEFAULT_BUFFER_SIZE+128+128,  //size of buffers in default heap
124     128, //tail room
125     256, //extra room
126     0,
127     NULL
128 };
130 NETAPI_T netapi_handle;
131 NETAPI_SCHED_HANDLE_T * our_sched;
132 #ifdef netTest_MULTI_THREAD
133 NETAPI_SCHED_HANDLE_T * scheduler[TUNE_NETAPI_NUM_CORES];
134 #endif
135 NETAPI_SCHED_CONFIG_T our_sched_cfg={
136   NETAPI_SCHED_DURATION|NETAPI_SCHED_CBV, 0, house, 5000000  //every 5000000 poll loops
137 };
139 netTestSA_t sa_info[MAX_SEC_INDEX];
140 NETCP_CFG_IPSEC_POLICY_T rx_policy[MAX_SEC_INDEX];
142 int masterType = NETAPI_SYS_MASTER;
148 /********************************************************************
149  * FUNCTION PURPOSE:  Utility function to flip and packet and send
150  *                    it back to its source.
151  ********************************************************************
152  * DESCRIPTION:   Utility function to flip and packet and send
153  *                    it back to its source.
154  ********************************************************************/
155 void flip_and_send_pkt(Ti_Pkt *tip,  unsigned char * p_pkt, int len, int flag, uint16_t enet_port)
157     unsigned char mac_temp[6];
158     unsigned char ip_temp[4];
159     unsigned char new_dest_port[2]={0x75,0x30};  // 30000
160     uint16_t dest_udp_port_config = 0;
161     uint16_t blah; 
162     uint16_t i=1;   /* for testing only */
164     uint8_t *p_spi; 
165     netTestSA_t * p_sa_info;
166     netTestSA_t *p_sa_info_tx;
167     uint8_t p_iv[16];
168     uint8_t p_add[8];
169     Cppi_HostDesc*          pPloadDesc;
170     uint8_t ah_len;
171     uint32_t tunnel_id;
172     nwalLocCxtInfo_t    nwalLocCxt;
173     netTestHead_T * p_head;
174     netTestHead_T temp_head;
175     int pkt_type;
177 #ifdef netTest_MULTI_THREAD
178     int coreid=Osal_nwalGetProcId(); //who we are(thread local)
179         //int coreid = our_core;
180 #else
181 int coreid=0;
182 #endif
183               // netTest_utilDumpBuffer((long*)p_pkt,len);
184     Pktlib_setPacketLen(tip,len);
185     //flip the mac address
186     memcpy(&mac_temp,&p_pkt[0],6);
187     memcpy(&p_pkt[0],&p_pkt[6],6);
188     memcpy(&p_pkt[6],&mac_temp,6);
189     //memcpy(&p_pkt[0],real_mac_header,6); //for testing to wireshark pc
191     //flip the ip  (outer in case of ipsec)
192     memcpy(&ip_temp, &p_pkt[netTest_MAC_HEADER_LEN+12],4);
193     memcpy(&p_pkt[netTest_MAC_HEADER_LEN+12],&p_pkt[netTest_MAC_HEADER_LEN+12+4],4);
194     memcpy(&p_pkt[netTest_MAC_HEADER_LEN+12+4],&ip_temp,4);
196     p_head=&temp_head;
198     //inner ip &udp for ipsec
199     if (flag) 
200     {
201         memcpy(p_head,&p_pkt[netTest_MAC_HEADER_LEN],sizeof(netTestHead_T));
203         if ((p_head->ip[2]&0x0000ff00)==0x00003300)
204         {
205             p_spi = &(p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN + 4]);
206             pkt_type = netTest_IPSEC_AH_PKT;
207         }
208         else if ((p_head->ip[2]&0x0000ff00)==0x00003200)
209         {
210             p_spi = &(p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN]);
211             pkt_type = netTest_IPSEC_ESP_PKT;
212         }
213         else
214         {
215             netapi_Log("flip_and_send_pkt: un-supported IPSEC protocol\n");
216             Pktlib_freePacket(tip);
217             return;
218         }
220         p_sa_info = (netTestSA_t *) trie_lookup(p_trie_sa_rx, (char *)p_spi ,4);
221         if (p_sa_info == NULL)
222         {
223             netapi_Log("flip_and_send_pkt(): trie_lookup() failed\n");
224             Pktlib_freePacket(tip);
225             return;
226         }
227         tunnel_id = p_sa_info->tunnel_id;
228         p_sa_info_tx = (netTestSA_t *) trie_lookup(p_trie_sa_tx, (char *)&tunnel_id ,4);
229         if (p_sa_info_tx == NULL)
230         {
231             netapi_Log("flip_and_send_pkt(): trie_lookup() failed\n");
232             Pktlib_freePacket(tip);
233             return;
234         }
235         //just drop non-udp packet
236         if (p_pkt[p_sa_info->tx_payload_info.encOffset+9]!=0x11)
237         {
238             stats[coreid].n_new+=1;Pktlib_freePacket(tip); return;
239         }
241         /* flip inner IP */
242         memcpy(&ip_temp, &p_pkt[p_sa_info->tx_payload_info.encOffset+12],4);
243         memcpy(&p_pkt[p_sa_info->tx_payload_info.encOffset+12],&p_pkt[p_sa_info->tx_payload_info.encOffset+12+4],4);
244         memcpy(&p_pkt[p_sa_info->tx_payload_info.encOffset+12+4],&ip_temp,4);
245         /* setting udp ports */
246         if (netTestCfg.dest_udp_port_config == 0)
247         {
248             memcpy(&p_pkt[p_sa_info->tx_payload_info.encOffset+netTest_IP_HEADER_LEN+2],
249                    &p_pkt[p_sa_info->tx_payload_info.encOffset+netTest_IP_HEADER_LEN],2);
250         }
251         else
252         {
253            dest_udp_port_config = htons(netTestCfg.dest_udp_port_config);
254             memcpy(&p_pkt[p_sa_info->tx_payload_info.encOffset+netTest_IP_HEADER_LEN+2],
255                    &dest_udp_port_config,2);
256         }
257         memset(&p_pkt[p_sa_info->tx_payload_info.encOffset+netTest_IP_HEADER_LEN+6],0,2); //checksum
259         if (netTestCfg.ipsec_mode_tx == IPSEC_MODE_TX_SIDEBAND)
260         {
261             /* inner ip checksum : leave alone, outer ip, set to 0 (we will compute on way out */
262             memset(&p_pkt[netTest_MAC_HEADER_LEN+10],0,2);
263         }
264     }
265     else
266     {
267         /* flip udp port */
268         if (netTestCfg.dest_udp_port_config == 0)
269         {
270             memcpy(&p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN+2],
271                    &p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN],2);
272         }
273         else
274         {
275             dest_udp_port_config = htons(netTestCfg.dest_udp_port_config);
276             //memcpy(&p_pkt[netTest_MAC_HEADER_LEN+20+2],&new_dest_port[0],2);
277             memcpy(&p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN+2],&dest_udp_port_config,2);
278         }
279         memset(&p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN+6],0,2);//0 udp checksum (we will compute on way out)
280     }
282     /*IPSEC case */ 
283     if (flag)
284     {
285         if (netTestCfg.ipsec_mode_tx == IPSEC_MODE_TX_SIDEBAND)
286         //send to crypto for encryption
287         //12 byte auth tag
288         {
289             PKTIO_METADATA_T meta = {PKTIO_META_SB_TX,{0},0};
290             int err;
291             nwalDmTxPayloadInfo_t meta_tx={0};
292             
293             meta.sa_handle = (void*)p_sa_info_tx->tx_tunnel;  //use TX SA APPID
295             memcpy(&meta_tx, &(p_sa_info->tx_payload_info), sizeof(nwalDmTxPayloadInfo_t));
296             meta_tx.appCtxId = (nwal_AppId)p_sa_info_tx;
297             meta_tx.encSize = len - p_sa_info->tx_payload_info.encOffset -p_sa_info->auth_tag_size;
298             meta_tx.authSize = len - meta_tx.authOffset - p_sa_info->auth_tag_size;
299             meta_tx.pAuthIV=NULL;
300             meta_tx.aadSize=0;
301             meta_tx.pAad=NULL;
302             if (p_sa_info->cipherMode ==  NWAL_SA_EALG_AES_CTR)
303             {
304                 memcpy(&p_iv[0], &p_sa_info->key_params->pEncKey[16], 4);
305                 memcpy(&p_iv[4], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
306                 p_iv[12] = 0;
307                 p_iv[13] = 0;
308                 p_iv[14] = 0;
309                 p_iv[15] = 1;
310                 meta_tx.pEncIV = &p_iv[0];
311             }
312             else if ((p_sa_info->cipherMode == NWAL_SA_EALG_AES_GCM) || (p_sa_info->cipherMode == NWAL_SA_EALG_AES_CCM))
313             {
314                 memcpy(&p_iv[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
315                 meta_tx.pEncIV = &p_iv[0];
316                 memcpy(&p_add[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN], 8);
317                 meta_tx.pAad= &p_add[0];
318                 meta_tx.aadSize = 8;
319             }
320             else if (p_sa_info->authMode == NWAL_SA_AALG_GMAC)
321             {
322                 memcpy(&p_iv[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
323                 meta_tx.pAuthIV= &p_iv[0];
324                 memcpy(&p_add[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN], 8);
325                 meta_tx.pAad= &p_add[0];
326                 meta_tx.aadSize = 8;
327             }
328             else if (p_sa_info->cipherMode ==  NWAL_SA_EALG_NULL)
329             {
330                 meta_tx.pEncIV = NULL;
331             }
332             else
333             {
334                 meta_tx.pEncIV = &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN ];
335             }
336             /* post it to netcp sb tx channel*/
337             meta.u.tx_sb_meta=&meta_tx;
339             netapi_pktioSend(netcp_sb_tx_chan,tip,&meta,&err);
340         }
341         else
342         {
343             //INFLOW TX, send pkt directly, asking for IP and UDP checksum offloads AND IPSEC to be applied
344             PKTIO_METADATA_T meta = {PKTIO_META_TX,{0},0};
345             int err;
346             nwalTxPktInfo_t meta_tx={0};
348             meta.sa_handle = (void*)p_sa_info_tx->tx_tunnel;  //use TX SA APPID
350             meta_tx.startOffset = p_sa_info_tx->tx_pkt_info.startOffset;
351             meta_tx.ipOffBytes =p_sa_info_tx->tx_payload_info.encOffset; 
352             meta_tx.l4OffBytes = p_sa_info_tx->tx_pkt_info.l4OffBytes;
353             meta_tx.l4HdrLen = p_sa_info_tx->tx_pkt_info.l4HdrLen;
354             meta_tx.ploadLen = (unsigned) ((p_pkt[meta_tx.l4OffBytes+4]<<8)|p_pkt[meta_tx.l4OffBytes+4+1]) -8 ;
355             meta_tx.saOffBytes=  p_sa_info_tx->tx_pkt_info.saOffBytes;
356             if (pkt_type == netTest_IPSEC_AH_PKT)
357             {
358                 memset(&p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN+netTest_IPSEC_AH_FIXED_HDR_SIZE],0,netTest_IPSEC_AH_FIXED_HDR_SIZE);
359                 meta_tx.txFlag1 = p_sa_info_tx->tx_pkt_info.txFlag1;
360                 meta_tx.saPayloadLen=len-netTest_MAC_HEADER_LEN;   //don't inlcude mac 
361                 meta_tx.saAhMacSize = 12;
362                 meta_tx.saAhIcvOffBytes = netTest_MAC_HEADER_LEN + netTest_IP_HEADER_LEN + netTest_IPSEC_AH_FIXED_HDR_SIZE;
363                 
364                 meta_tx.enetPort = enet_port;
365                  memcpy(&p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN+4],&p_sa_info_tx->spi,4);
366             }
367             else if (pkt_type == netTest_IPSEC_ESP_PKT)
368             {
369                 meta_tx.txFlag1 = p_sa_info_tx->tx_pkt_info.txFlag1;
370                 meta_tx.saPayloadLen=len-netTest_MAC_HEADER_LEN-netTest_IP_HEADER_LEN;   //don't include mac and ip outer header
371                 meta_tx.enetPort = 0;
372                  memcpy(&p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN],&p_sa_info_tx->spi,4);
373             }
374             else
375             {
376                 printf("flip_and_send_pkt: invalid ESP protocol\n");
377                 return;
378             }
380             meta_tx.pseudoHdrChecksum =
381             netTest_utilGetIPv4PsudoChkSum(&p_pkt[meta_tx.ipOffBytes],8+ meta_tx.ploadLen);
384             /* post it to netcp tx channel*/
385             meta.u.tx_meta=&meta_tx;
386 #ifdef DEBUG_DESC
387             if (stats[coreid].sec_tx<20) netTest_utilDumpDescr((long *) tip, stats[coreid].sec_tx);
388 #endif
389             if ( pkt_type == netTest_IPSEC_ESP_PKT)
390                 netapi_pktioSend(netcp_tx_chan_esp,tip,&meta,&err);
391             else if ( pkt_type == netTest_IPSEC_AH_PKT)
392                  netapi_pktioSend(netcp_tx_chan_ah,tip,&meta,&err);
393             stats[coreid].tx +=1;
394             stats[coreid].sec_tx +=1;
395         }
396     }
397     else  //non ipsec send pkt directly, asking for IP and UDP checksum ofload
398     {
399         PKTIO_METADATA_T meta2 = {PKTIO_META_TX,{0},0};
400         int err;
401         nwalTxPktInfo_t meta_tx2={0};
402         meta2.sa_handle=nwal_HANDLE_INVALID;
403         meta_tx2.txFlag1 = (NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID );
404         meta_tx2.startOffset = 0;
405         meta_tx2.ipOffBytes = netTest_MAC_HEADER_LEN;
406         meta_tx2.l4OffBytes = netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN;
407         meta_tx2.l4HdrLen = netTest_UDP_HEADER_LEN;
408         meta_tx2.ploadLen = (unsigned) ((p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN+4]<<8)|
409                                         p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN+4+1]) -8 ;
410         meta_tx2.pseudoHdrChecksum =
411         netTest_utilGetIPv4PsudoChkSum(&p_pkt[netTest_MAC_HEADER_LEN],8+ meta_tx2.ploadLen);
413         /* post it to netcp tx channel*/
414         meta2.u.tx_meta=&meta_tx2;
415         netapi_pktioSend(netcp_tx_chan_no_crypto,tip,&meta2,&err);
416         stats[coreid].tx +=1;
417     }
421 /**********************************************************************
422  * FUNCTION PURPOSE:  Sideband Accelerator Callback PKT RECEIVE HANDLER
423  **********************************************************************
424  * DESCRIPTION:   Sideband Accelerator Callback PKT RECEIVE HANDLER
425  *                Handles Decrypt and Encrypt operation callbacks
426  **********************************************************************/
427 void recv_sb_cb(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
428                          PKTIO_METADATA_T meta[], int n_pkts,
429                          uint64_t ts )
431     int i;
432     int len;
433     int p;
434     netTestHead_T * p_res;
435     Ti_Pkt * tip;
436     unsigned int templen;
437     int err;
438     char * p_pkt;
439     netTestHead_T * p_head;
440     netTestHead_T temp_head;
441     int tag_cmp=0;
442     unsigned int hash[4];
443     uint8_t *p_spi;
444     netTestSA_t *p_sa_info;
446 #ifdef netTest_MULTI_THREAD
447     int coreid=Osal_nwalGetProcId();  //who we are(thread local)
448 #else
449     int coreid=0;
450 #endif
451     //nwal_AppId time;
452     unsigned long time = 0;
453     unsigned long delta_time = 0;
454     /* loop over received pkts */
455     for(i=0;i<n_pkts;i++)
456    {
457         tip = p_recv[i];
458         Pktlib_getDataBuffer(tip,(uint8_t**)&p_pkt,&templen);//ignore templen
459         len = Pktlib_getPacketLen(tip);//real length
461         /*p_sa_info is for rx context */
462         p_sa_info = (netTestSA_t*)meta[i].u.rx_sb_meta->appCtxId;
463         if (p_sa_info == NULL)
464         {
465             printf("recv_sb_cb(): trie_lookup failed\n");
466             continue;
467         }
469         //is this a decrypt (rx_tunnel) complete
470         if ((int)meta[i].u.rx_sb_meta->appId == p_sa_info->rx_tunnel)
471         {
472             //time = hplib_mUtilGetPmuCCNT();
473             //delta_time = time -(unsigned long) meta[i].u.rx_sb_meta->appCtxId;
474             stats[coreid].total_decrypt_time += delta_time;
475             stats[coreid].sb_rx+=1;
476             //copy hash out of meta data (for some reason it needs endian conversion)
477             hash[0]= netTest_utilHtonl( meta[i].u.rx_sb_meta->pAuthTag[0]);
478             hash[1]= netTest_utilHtonl( meta[i].u.rx_sb_meta->pAuthTag[1]);
479             hash[2]= netTest_utilHtonl( meta[i].u.rx_sb_meta->pAuthTag[2]);
480             hash[3]= netTest_utilHtonl( meta[i].u.rx_sb_meta->pAuthTag[3]);
481             if(stats[coreid].sb_rx<=16)
482             {
483                 char *tp = (char *) &hash[0];
484                 //netTest_utilDumpHeader((long*)p_pkt, stats[coreid].sb_rx, (int)meta[i].u.rx_sb_meta->appId,0);
485             }
486             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
487             stats[coreid].n_auth_ok += !(tag_cmp);
488             flip_and_send_pkt(tip, p_pkt, len,1, 0);  //flip packet to echo back and send
489         }
490         //this is an encrypt (tx tunnel) complete
491         else if((int)meta[i].u.rx_sb_meta->appId== p_sa_info->tx_tunnel )
492         {
493             hash[0]= netTest_utilHtonl( meta[i].u.rx_sb_meta->pAuthTag[0]);
494             hash[1]= netTest_utilHtonl( meta[i].u.rx_sb_meta->pAuthTag[1]);
495             hash[2]= netTest_utilHtonl( meta[i].u.rx_sb_meta->pAuthTag[2]);
496             hash[3]= netTest_utilHtonl( meta[i].u.rx_sb_meta->pAuthTag[3]);
497             stats[coreid].sb_tx+=1;
498             if(stats[coreid].sb_tx<=16)
499             {
500                 //netTest_utilDumpHeader((long*)p_pkt, stats[coreid].sb_tx, (int)meta[i].u.rx_sb_meta->appId,0);
501             }
502             //put the computed tag in the packet
503              memcpy(&p_pkt[len-p_sa_info->auth_tag_size],(char*)&hash[0],p_sa_info->auth_tag_size); //todo, really use meta->authTagLen
504             {
505                 PKTIO_METADATA_T meta2 = {PKTIO_META_TX,{0},0};
506                 nwalTxPktInfo_t meta_tx={0};
507                 // now send directly 
508                 meta2.sa_handle=nwal_HANDLE_INVALID;
509                 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
510                 meta_tx.startOffset = 0;
511                 meta_tx.ipOffBytes = netTest_MAC_HEADER_LEN;
512                 meta_tx.l4OffBytes = 0;
513                 meta_tx.l4HdrLen = 0;
514                 meta_tx.ploadLen = 0;
515                 time = hplib_mUtilGetPmuCCNT();
516                 delta_time = time -(unsigned long) meta[i].u.rx_sb_meta->appCtxId;
517                 stats[coreid].total_encrypt_time += delta_time;
519                 /* post it to netcp tx channel*/
520                 meta2.u.tx_meta=&meta_tx;
521                 netapi_pktioSend(netcp_tx_chan_no_crypto,tip,&meta2,&err);
522                 //netapi_pktioSend(netcp_tx_chan_esp,tip,&meta2,&err);
523                 hplib_cacheWbInv(p_pkt,len);
524                 stats[coreid].tx +=1;
525             }
526         }
527         else printf("netapi recv_sb_cb: unknown appiD %x \n",meta[i].u.rx_sb_meta->appId );
528     }
531 /**********************************************************************
532  * FUNCTION PURPOSE:  Packet receive Callback
533  *
534  **********************************************************************
535  * DESCRIPTION:   packet Receive callback
536  **********************************************************************/
537 void recv_cb(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
538                          PKTIO_METADATA_T meta[], int n_pkts,
539                          uint64_t ts )
541     int i;
542     int len;
543     int p;
544     netTestHead_T * p_res;
545     Ti_Pkt * tip;
546     unsigned int templen;
547     int err = 0;
548     char * p_pkt;
549     netTestHead_T * p_head;
550     netTestHead_T temp_head;
551     netTestSA_t *p_sa_info;
552     uint8_t *p_spi;
553     uint8_t p_iv[16];
554     uint8_t p_add[8];
555     uint8_t p_add1[1500];
556     int16_t       retVal;
557     unsigned long t1;
558     unsigned long t2;
559     unsigned long long ct1;
560     unsigned long long ct2;
561     unsigned long long n_c_ops;
562     nwalGlobCxtInfo_t   nwalGlobCxt;
563     nwalLocCxtInfo_t    nwalLocCxt;
565     Cppi_HostDesc*          pPloadDesc;
566     int ifno;
567     uint16_t enet_port = 0;
569 #ifdef netTest_MULTI_THREAD
570     int coreid=Osal_nwalGetProcId();  //who we are(thread local)
571 #else
572     int coreid=0;
573 #endif
574     p_head=&temp_head;
576     t1=hplib_mUtilGetPmuCCNT();
577     ct1 =Osal_cache_op_measure(&n_c_ops);
579     /* loop over received pkts */
580     for(i=0;i<n_pkts;i++)
581     {
582         ifno = ((unsigned int)meta[i].u.rx_meta->appId)&0xff;
583         
584         enet_port = meta[i].u.rx_meta->enetPort;
585         tip = p_recv[i];
587         Pktlib_getDataBuffer(tip,(uint8_t**)&p_pkt,&templen);/*ignore templen */
588         len = Pktlib_getPacketLen(tip)-4;   /*real length, subtract mac trailer */
589         Cppi_setData (Cppi_DescType_HOST, (Cppi_Desc *) tip, p_pkt,len);
590         Pktlib_setPacketLen(tip,len);
592         if(((unsigned int)meta[i].u.rx_meta->appId) == expPkt_appid)
593         {
594             netapi_Log("recv_cb: received exception packet\n");
595             Pktlib_freePacket(tip);
596             if(((unsigned int)meta[i].u.rx_meta->rxFlag1  & NWAL_RX_IP_FRAGMENT_PKT) ==
597                                              NWAL_RX_IP_FRAGMENT_PKT)
598             {
599                 stats[coreid].exceptionPktsFrag+=1;
600             }
601             else
602             {
603                 stats[coreid].exceptionPktsOther+=1;
604             }
605             continue;
606         }
607         //debug: validate descriptor */
608         if(Pktlib_getNextPacket(tip) != 0) 
609         {
610             printf(" rcv_cb, nexpkt != NULL");
611         }
613         if(coreid<TUNE_NETAPI_NUM_CORES)
614         {
615             stats[coreid].rx+=1;
616             if (ifno < TUNE_NETAPI_MAX_NUM_MAC)
617                 stats[coreid].if_rx[ifno]+=1;
618         }
620 #ifdef DEBUG_DESC
621         if(coreid<TUNE_NETAPI_NUM_CORES)
622         {
623             if (stats[coreid].rx<16)
624             {
625                 netapi_Log(">rx dmp.."); 
626                 netTest_utilDumpDescr((long *) tip, stats[coreid].rx);
627             }
628             else if (stats[coreid].rx>99) 
629             {
630                 netapi_Log(">rx dmp.."); 
631                 netTest_utilDumpDescr((long *) tip,stats[coreid].rx);
632             }
633         }
634 #endif
635 #if 0
636         //
637         if(stats[coreid].rx<=16)
638         {
639             netTest_utilDumpHeader((long*)p_pkt,stats[coreid].rx, (int)meta[i].u.rx_meta->appId,meta[i].u.rx_meta->rxFlag1);
640             netTest_utilDumpBuffer((long*)p_pkt,len);
641         }
642 #endif
643         /* check header */
644         memcpy(p_head,&p_pkt[netTest_MAC_HEADER_LEN],sizeof(netTestHead_T));
646         /* check for IPSEC ESP or AH packet, 0x32 is ESP tunnel mode, 0x33 is AH tunnel mode*/
647         if (((p_head->ip[2]&0x0000ff00)==0x00003200) || ((p_head->ip[2]&0x0000ff00)==0x00003300))
648         {
649             if (!netTest_utilCheckHeader(p_head,&meta[i]))
650             {
651                 printf("recv_cb: error in ipsec pkt\n");
652                 stats[coreid].n_bad+=1;Pktlib_freePacket(tip); 
653                 continue;
654             }
656             //process IP SEC PACKET
657             if (netTestCfg.ipsec_mode_rx == IPSEC_MODE_RX_SIDEBAND)
658             {
659                 p_spi = &(p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN]);
660                 p_sa_info = (netTestSA_t *) trie_lookup(p_trie_sa_rx, (char *)p_spi ,4);
661                 if (p_sa_info == NULL)
662                 {
663                     printf("recv_cb(): trie_lookup() failed\n");
664                     continue;
665                 }
667                 //ship to crypto for decrypt!!
668                 //12 byte auth tag
669                 PKTIO_METADATA_T meta2 = {PKTIO_META_SB_TX,{0},0};
670                 nwalDmTxPayloadInfo_t meta_tx={0};
672                 meta2.sa_handle = (void*) p_sa_info->rx_tunnel;
674                 memcpy(&meta_tx, &(p_sa_info->tx_payload_info), sizeof(nwalDmTxPayloadInfo_t));
676                 meta_tx.encSize = len - p_sa_info->tx_payload_info.encOffset -p_sa_info->auth_tag_size;
677                 meta_tx.authSize = len - meta_tx.authOffset - p_sa_info->auth_tag_size;
679                 if (p_sa_info->cipherMode == NWAL_SA_EALG_AES_CTR)
680                 {
681                     memcpy(&p_iv[0], &p_sa_info->key_params->pEncKey[16], 4);
682                     memcpy(&p_iv[4], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
683                     p_iv[12] = 0;
684                     p_iv[13] = 0;
685                     p_iv[14] = 0;
686                     p_iv[15] = 1;
687                     meta_tx.pEncIV = &p_iv[0];
688                  
689                 }
690                 else if ((p_sa_info->cipherMode == NWAL_SA_EALG_AES_GCM) ||
691                             (p_sa_info->cipherMode == NWAL_SA_EALG_AES_CCM))
692                 {
693                         memcpy(&p_iv[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
694                         meta_tx.pEncIV = &p_iv[0];
695                         /* aad is the ESP header which is 8 bytes */
696                         memcpy(&p_add[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN], 8);
697                         meta_tx.pAad= &p_add[0];
698                         meta_tx.aadSize = 8;
699                 }
700                 else if (p_sa_info->authMode == NWAL_SA_AALG_GMAC)
701                 {
702                     memcpy(&p_iv[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
703                         meta_tx.pAuthIV= &p_iv[0];
704                         /* aad is the ESP header which is 8 bytes */
705                         memcpy(&p_add[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN], 8);
706                         meta_tx.pAad= &p_add[0];
707                         meta_tx.aadSize = 8;
708                 }
709                 else if (p_sa_info->cipherMode ==  NWAL_SA_EALG_NULL)
710                 {
711                     meta_tx.pEncIV = NULL;
712                 }
713                 else
714                 {
715                     meta_tx.pEncIV = &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN ];
716                 }
717                
718                 meta_tx.appCtxId = (nwal_AppId)p_sa_info;
720                 /* post it to netcp sb tx channel*/
721                 meta2.u.tx_sb_meta=&meta_tx;
723                 netapi_pktioSend(netcp_sb_tx_chan,tip,&meta2,&err);
724                 continue;
725             }
726             else
727             {
728                 //inflow mode.  flip and send
729                 flip_and_send_pkt(tip,p_pkt,len,1, enet_port);
730             }
731         }
732         /* check for udp protocol */
733         else if ((p_head->ip[2]&0x0000ff00)!=0x00001100)
734          //else if ((p_head->ip[2]&0x00ff0000)!=0x00110000)
735         {
736             stats[coreid].n_new+=1;Pktlib_freePacket(tip); continue;
737         }
738         else  //non ipsec
739         {
740             if (!netTest_utilCheckHeader(p_head,&meta[i]))
741             {
742                 stats[coreid].n_bad+=1;Pktlib_freePacket(tip);
743                 continue;
744             }
745             //just flip and send
746             flip_and_send_pkt(tip,p_pkt,len,0, enet_port);
747         }
748     }
749     t2=hplib_mUtilGetPmuCCNT();
750     ct2 =Osal_cache_op_measure(&n_c_ops);
751     stats[coreid].app_cycles +=  (unsigned long long) (t2-t1);
752     stats[coreid].tx_cache_cycles += (unsigned long long) (ct2-ct1);
755 /* Templates to build command labels at startup up time, required by open_pktio_tx_channels() */
756 nwalTxPktInfo_t txPktInfoESP = 
758     NULL,                                                                                               /* p_pkt */
759     NWAL_TX_FLAG1_DO_IPSEC_ESP_CRYPTO| NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID,      /* txFlags */
760     0,                                                                                                  /* lpbackPass */
761     0,                                                                                                  /* enetport */
762     0,                                                                                                  /* msuSize */
763     0,                                                                                                   /* startOffset */
764     netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN,                                                    /* saOffBytes */
765     0,                                                                                                  /* saPayLoadLen */
766     0               ,                                                                                    /* saAhIcvOffBytes */
767     0,                                                                                                 /* saAhMacSize */
768     0,                                                                                                  /* etherLenOffBytes */
769     0,                                                                                                  /* ipOffBytes */
770     0,                                                                                                  /* l4OffBytes */
771     netTest_UDP_HEADER_LEN,                                                                             /* l4HdrLen */
772     0,                                                                                                  /* pseudoHdrChecksum */
773     0                                                                                                   /* pLoadLen */
774 };
777 nwalTxPktInfo_t txPktInfoAH = 
779     NULL,                                                                                               /* p_pkt */
780     NWAL_TX_FLAG1_DO_IPSEC_AH_CRYPTO| NWAL_TX_FLAG1_DO_UDP_CHKSUM | NWAL_TX_FLAG1_META_DATA_VALID,      /* txFlags */
781     0,                                                                                                  /* lpbackPass */
782     0,                                                                                                  /* enetport */
783     0,                                                                                                  /* msuSize */
784     0,                                                                                                   /* startOffset */
785     netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN,                                                    /* saOffBytes */
786     0,                                                                                                  /* saPayLoadLen */
787     netTest_MAC_HEADER_LEN + netTest_IP_HEADER_LEN + netTest_IPSEC_AH_FIXED_HDR_SIZE,                    /* saAhIcvOffBytes */
788     12,                                                                                                 /* saAhMacSize */
789     0,                                                                                                  /* etherLenOffBytes */
790     0,                                             /* ipOffBytes */
791     0,                                                                                                  /* l4OffBytes */
792     netTest_UDP_HEADER_LEN,                                                                            /* l4HdrLen */
793     0,                                                                                                  /* pseudoHdrChecksum */
794     0                                                                                                   /* pLoadLen */
795 };
797 nwalTxPktInfo_t txPktInfoNoCrypto = 
799     NULL,                                                                                               /* p_pkt */
800     NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID,      /* txFlags */
801     0,                                                                                                  /* lpbackPass */
802     0,                                                                                                  /* enetport */
803     0,                                                                                                  /* msuSize */
804     0,                                                                                                   /* startOffset */
805     0,                                                    /* saOffBytes */
806     0,                                                                                                  /* saPayLoadLen */
807     0               ,                                                                                    /* saAhIcvOffBytes */
808     0,                                                                                                 /* saAhMacSize */
809     0,                                                                                                  /* etherLenOffBytes */
810     0,                                                                                                  /* ipOffBytes */
811     netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN,                                        /* l4OffBytes */
812     netTest_UDP_HEADER_LEN,                                                             /* l4HdrLen */
813     0,                                                                         /* pseudoHdrChecksum */
814     0                                                                                                   /* pLoadLen */
815 };
818 void close_pktio_channels(void)
820     int err;
821     netapi_pktioClose(netcp_tx_chan_esp ,&err);
822     netapi_pktioClose(netcp_tx_chan_ah ,&err);
823     netapi_pktioClose(netcp_sb_tx_chan ,&err);
824     netapi_pktioClose(netcp_tx_chan_no_crypto,&err);
827 void open_pktio_tx_channels(void)
829     int err;
830     /* open netcp default  TX for ESP packets */
831     netcp_tx_chan_esp= netapi_pktioOpen(netapi_handle, NETCP_TX, NULL, &netcp_tx_cfg,  &err);
832     if (!netcp_tx_chan_esp)
833     {
834         printf("pktio open TX failed err=%d\n",err);
835         exit(1);
836     }
837     else
838     {
839         if(netTestCfg.ipsec_mode_tx == IPSEC_MODE_TX_INFLOW)
840         {
841             PKTIO_CONTROL_T control;
842             control.op = PKTIO_UPDATE_FAST_PATH;
843             PKTIO_CFG_T cfg;
844             cfg.fast_path_cfg.fp_send_option = PKTIO_FP_ESP_L4CKSUM_PORT;
845             cfg.fast_path_cfg.txPktInfo= &txPktInfoESP;
846             netapi_pktioControl(netcp_tx_chan_esp, NULL, &cfg, &control, &err);
847         }
848     }
850     /*/* open netcp default  TX for AH packets */
851     netcp_tx_chan_ah= netapi_pktioOpen(netapi_handle, NETCP_TX, NULL, &netcp_tx_cfg,  &err);
852     if (!netcp_tx_chan_ah)
853     {
854         printf("pktio open TX failed err=%d\n",err);
855         exit(1);
856     }
857     else
858     {
859         if(netTestCfg.ipsec_mode_tx == IPSEC_MODE_TX_INFLOW)
860         {
861             PKTIO_CONTROL_T control;
862             control.op = PKTIO_UPDATE_FAST_PATH;
863             PKTIO_CFG_T cfg;
864             cfg.fast_path_cfg.fp_send_option = PKTIO_FP_AH_L4CKSUM_PORT;
865             cfg.fast_path_cfg.txPktInfo= &txPktInfoAH;
866             netapi_pktioControl(netcp_tx_chan_ah, NULL, &cfg, &control, &err);
867         }
868     }
870     /* open netcp default  TX channels for non-Crypto packets */
871     netcp_tx_chan_no_crypto= netapi_pktioOpen(netapi_handle, NETCP_TX, NULL, &netcp_tx_cfg,  &err);
872     if (!netcp_tx_chan_no_crypto)
873     {
874         printf("pktio open TX failed err=%d\n",err);
875         exit(1);
876     }
877     else
878     {
879         if(netTestCfg.ipsec_mode_tx == IPSEC_MODE_TX_INFLOW)
880         {
881             PKTIO_CONTROL_T control;
882             control.op = PKTIO_UPDATE_FAST_PATH;
883             PKTIO_CFG_T cfg;
884             cfg.fast_path_cfg.fp_send_option = PKTIO_FP_L4CKSUM_PORT;
885             cfg.fast_path_cfg.txPktInfo= &txPktInfoNoCrypto;
886             netapi_pktioControl(netcp_tx_chan_no_crypto, NULL, &cfg, &control, &err);
887         }
888     }
890     /* open netcp default  TX channels for SB crypto */
891     netcp_sb_tx_chan= netapi_pktioOpen(netapi_handle, NETCP_SB_TX, NULL, &netcp_sb_tx_cfg,  &err);
892     if (!netcp_sb_tx_chan)
893     {
894         printf("pktio open SB TX failed err=%d\n",err);
895         exit(1);
896     }
899 #ifdef netTest_DSP_FASTPATH
900 void setup_netTestDSPFastPath(NETAPI_T handle)
903     int i;
904     int err = 0;
905     PKTIO_CFG_T dsp_pktio_cfg;
906     NETCP_CFG_CLASSIFIER_T dsp_classi;
907     NETCP_CFG_ROUTE_T dsp_route;
909     memset(&dsp_pktio_cfg, 0, sizeof (PKTIO_CFG_T));
910     memset(&dsp_classi, 0, sizeof (NETCP_CFG_CLASSIFIER_T));
911     memset(&dsp_route, 0, sizeof (NETCP_CFG_ROUTE_T));
912     char dsp_name[PKTIO_MAX_NAME];
913     for (i = 0; i < CPU_NUM_REM_FAST_PATH_CORES; i++)
914     {
915         snprintf(&dsp_name[0],32, "%s%d","dsp_chan", i);
916         dsp_pktio_cfg.flags1 = PKTIO_RX;
917         dsp_pktio_cfg.flags2 = PKTIO_PKT;
918         dsp_pktio_cfg.qnum = TEST_NWAL_BASE_REM_FP_RX_PKT_QUEUE + i;
919         dsp_pktio_cfg.max_n = 8;
921         /* pktio channels created here will NOT be POLLED by net_test arm application */
922         dsp_pktio_channels[i] = netapi_pktioCreate(handle,
923                                                &dsp_name[0],
924                                                (PKTIO_CB)recv_cb,
925                                                &dsp_pktio_cfg,
926                                                &err);
927         if (!dsp_pktio_channels[i])
928         {
929             netapi_Log("setup_netTestDSPFastPath: failed for core %d\n", i);
930         }
932         dsp_classi.classType =NETCP_CFG_CLASS_TYPE_L4;
933         dsp_classi.u.c_l4.iface = netTestCfg.dsp_mac;
934         
935         dsp_classi.u.c_l4.ip = ip_rule[netTestCfg.dsp_ip];
936         dsp_classi.u.c_l4.proto = NWAL_APP_PLOAD_PROTO_UDP;
937         dsp_classi.u.c_l4.appProto.udpPort = TEST_NWAL_BASE_REM_FP_UDP_PORT + i;
939         dsp_route.p_dest_q = dsp_pktio_channels[i];
940        
941         dsp_route.p_flow = (NETCP_CFG_FLOW_T*)NETCP_DEFAULT_FLOW;
942         
943         dsp_classifers[i] = netapi_netcpCfgAddClass(handle, 
944                                 &dsp_classi, 
945                                 (NETCP_CFG_ROUTE_HANDLE_T) &dsp_route, 
946                                 NETCP_CFG_ACTION_TO_SW,
947                                 NULL,
948                                 &err);
950         if (err != NETAPI_ERR_OK)
951         {
952             netapi_Log("setup_netTestDSPFastPath: netapi_netcpCfgAddClass failed for core %d\n", i);
953         }
954     }
955     printf("DSP Path fath setup complete\n");
958 void teardown_netTestDSPFastPath()
960     int i;
961     int err=0;
963     for (i = 0; i < CPU_NUM_REM_FAST_PATH_CORES; i++)
964     {
965         netapi_netcpCfgDelClass(netapi_handle,
966                                 dsp_classifers[i],
967                                 &err);
968         if (err != NETAPI_ERR_OK)
969         {
970             printf("teardown_netTestDSPFastPath: netapi_netcpCfgDelClass failed for core %d\n", i);
971         }
973         netapi_pktioDelete(dsp_pktio_channels[i],
974                            &err);
975         if (err != NETAPI_ERR_OK)
976         {
977             printf("teardown_netTestDSPFastPath: netapi_pktioDelete failed for core %d\n", i);
978         }
979     }
980     printf("DSP Path fath teardown complete\n");
982 #endif
985 #ifdef netTest_MULTI_THREAD
986 NETAPI_T worker_nh[TUNE_NETAPI_NUM_CORES];
988 void slow_path_thread(uint32_t index)
990     int err, i;;
991     uint32_t thread_num;
992     PKTIO_HANDLE_T *rx_chan;
993     PKTIO_HANDLE_T *sb_rx_chan;
996     cpu_set_t cpu_set;
998     thread_num = netTestCfg.sp_thread_num[index];
999     netapi_Log("slow_path_thread, mypid: %d, core_id %d\n", gettid(), netTestCfg.sp_thread_num[index]);
1001     CPU_ZERO( &cpu_set);
1002 #ifdef CORTEX_A8
1003     for (i = netTestCfg.sp_proc_start[index]; i <= netTestCfg.sp_proc_end[index];i++)
1004     {
1005         printf("slow_path_thread: setting cpu %d to cpu_set\n", i);
1006         CPU_SET( 0, &cpu_set);
1007     }
1008     hplib_utilSetupThread(thread_num, &cpu_set, hplib_spinLock_Type_LOL);
1009 #else
1010     for (i = netTestCfg.sp_proc_start[index]; i <= netTestCfg.sp_proc_end[index];i++)
1011     {
1012         CPU_SET( i, &cpu_set);
1013     }
1014     hplib_utilSetupThread(thread_num, &cpu_set, hplib_spinLock_Type_LOL);
1015 #endif
1016     worker_nh[thread_num] = netapi_init(NETAPI_CORE_MASTER,NULL);
1018     if (worker_nh[thread_num] == NULL)
1019     {
1020         printf("slow_path_thread: netapi_init failure, exiting\n");
1021         exit(1);
1022     }
1023     netapi_setCookie(worker_nh[thread_num],(void*)(thread_num | NET_TEST_SP_THREAD_MASK));
1025     scheduler[thread_num] =netapi_schedOpen(worker_nh[thread_num],&our_sched_cfg, &err);
1026     if (!scheduler[thread_num]) 
1027     {
1028         printf("sched create failed for core%d\n",thread_num);
1029         goto ERR_slow_path_thread;
1030     }
1031     scheduler[thread_num]->config.yield = NETAPI_TRUE;
1032     scheduler[thread_num]->config.pollGarbageQ = NETAPI_TRUE;
1033     scheduler[thread_num]->config.pollCtrlQ = NETAPI_TRUE;
1034     printf("Slow Path thread: %d setup complete, running on ARM CORE: %d\n", i,i);
1035     /* Entry point to scheduler */
1036     netapi_schedRun(scheduler[thread_num], &err);
1038 ERR_slow_path_thread:
1039     printf("slow_path_thread: calling netapi_shutdown\n");
1040     netapi_shutdown(worker_nh[thread_num]);
1043 void fast_path_thread(uint32_t index)
1045     int err, i;
1046     PKTIO_HANDLE_T *rx_chan;
1047     PKTIO_HANDLE_T *sb_rx_chan;
1048     uint32_t thread_num;
1051     cpu_set_t cpu_set;
1053     CPU_ZERO( &cpu_set);
1054     thread_num = netTestCfg.fp_thread_num[index];
1055 #ifdef CORTEX_A8
1056     for (i = netTestCfg.fp_proc_start[index]; i <= netTestCfg.fp_proc_end[index];i++)
1057     {
1058         CPU_SET( 0, &cpu_set);
1059     }
1060     hplib_utilSetupThread(thread_num, &cpu_set, hplib_spinLock_Type_LOL);
1061 #else
1062     for (i = netTestCfg.fp_proc_start[index]; i <= netTestCfg.fp_proc_end[index];i++)
1063     {
1064         netapi_Log("fast_path_thread: start core %d end core %d\n",
1065                 netTestCfg.fp_proc_start[index],
1066                 netTestCfg.fp_proc_end[index]);
1067         netapi_Log("fast_path_thread: setting cpu %d to cpu_set\n", i);
1068         CPU_SET( i, &cpu_set);
1069     }
1070     hplib_utilSetupThread(thread_num, &cpu_set, hplib_spinLock_Type_LOL);
1071 #endif
1072     hplib_mSpinLockLock(&net_test_thread_lock);
1073     worker_nh[thread_num]=netapi_init(NETAPI_CORE_MASTER,NULL);
1074     
1075     if (worker_nh[thread_num] == NULL)
1076     {
1077         printf("fast_path_thread: netapi_init failure, exiting\n");
1078         hplib_mSpinLockUnlock(&net_test_thread_lock);
1079         exit(1);
1080     }
1081     hplib_mSpinLockUnlock(&net_test_thread_lock);
1082     /* open netcp default RX channels*/
1083     rx_chan = netapi_pktioOpen(worker_nh[thread_num], NETCP_RX, (PKTIO_CB) recv_cb, &netcp_rx_cfg,  &err);
1085     netcp_rx_cfg.flags2 = PKTIO_PKT;
1087     if(masterType == NETAPI_SYS_MASTER)
1088         netapi_pktioOpen(worker_nh[thread_num], "sysMaster", (PKTIO_CB) recv_cb, &netcp_rx_cfg,  &err);
1090     else if(masterType == NETAPI_PROC_MASTER)
1091         netapi_pktioOpen(worker_nh[thread_num], "procMaster", (PKTIO_CB) recv_cb, &netcp_rx_cfg,  &err);
1093     /* create a pktio channel for specially classified pkts */
1094     /* open netcp default tx, rx queues for sideband crypto */
1095     sb_rx_chan = netapi_pktioOpen(worker_nh[thread_num], NETCP_SB_RX, (PKTIO_CB) recv_sb_cb, &netcp_sb_rx_cfg,  &err);
1097     netapi_setCookie(worker_nh[thread_num],(void*)thread_num);
1098     
1099     scheduler[thread_num] =netapi_schedOpen(worker_nh[thread_num],
1100                                             &our_sched_cfg,
1101                                             &err);
1102     if (!scheduler[thread_num]) 
1103         {
1104         printf("sched create failed for core%d\n",thread_num);
1105         goto ERR_fast_path_thread;
1106         //exit(1);
1107     }
1109  
1110     scheduler[thread_num]->config.yield = NETAPI_FALSE;
1111     scheduler[thread_num]->config.pollGarbageQ = NETAPI_FALSE;
1112     scheduler[thread_num]->config.pollCtrlQ = NETAPI_FALSE;
1113      //sleep(100000);
1114    /* Entry point to scheduler */
1115     printf("Fast Path thread: %d setup complete, running on ARM CORE: %d\n", i,i);
1116     netapi_schedRun(scheduler[thread_num], &err);
1118 ERR_fast_path_thread:
1119     netapi_pktioClose(rx_chan, &err);
1120     netapi_pktioClose(sb_rx_chan, &err);
1121     
1122     printf("fast_path_thread: calling netapi_shutdown\n");
1123     netapi_shutdown(worker_nh[thread_num]);
1126 #endif
1127 /***************************************
1128  ********** test driver*****************
1129  ***************************************/
1130 int main(int argc, char **argv)
1132     int err,i;
1133     Pktlib_HeapCfg      heapCfg;
1134     int32_t             errCode;
1135     Pktlib_HeapIfTable*  pPktifTable;
1136     FILE * fpr = NULL;
1137     int c;
1139     static char usage[] = "usage: %s -f < config File Name> -t <masterType: procMaster or sysMater> >\n";
1140 #ifdef netTest_MULTI_THREAD
1141     cpu_set_t cpu_set;
1142 #endif
1143      /* install signal handler for ^c */
1144     signal(SIGINT,netTest_utilMySig);
1147     while ((c = getopt (argc, argv, "f:t:?")) != -1)
1148     {
1149        switch (c)
1150        {
1151             case 'f':
1152                 fpr = fopen(optarg, "r");
1153                 printf("main: filename1 %s\n", optarg);
1154                 break;
1155             case 't':
1156                 if(strcmp("sysMaster", optarg) == 0)
1157                 {
1158                     masterType = NETAPI_SYS_MASTER;
1159                 }
1160                 else if (strcmp("procMaster", optarg) == 0)
1161                 {
1162                     masterType = NETAPI_PROC_MASTER;
1163                 }
1164                 else
1165                 {
1166                     printf("%s\n", usage);
1167                 }
1168                 printf("optionValue %s: %d\n", optarg, masterType);
1169                 break;
1171             case '?':
1172                 printf("optionValue %s: %d\n", optarg, masterType);
1173                 exit(EXIT_FAILURE);
1174                 break;
1175             default:
1176                 break;
1177         }
1178     }
1180     if (fpr ==NULL)
1181         fpr = fopen(input_file_name, "r");
1182     if (initRm())
1183     {
1184         printf("main: initRm() returned error\n");
1185         exit(1);
1186     }
1187     hplib_mSpinLockInit(&net_test_thread_lock );
1188     our_netapi_default_cfg.rmHandle = rmClientServiceHandle;
1189     memset(&config_file, 0, sizeof(netTestConfigFile_t));
1190     memset(&netTestCfg, 0, sizeof(netTestConfig_t));
1192     netTest_utilProcessConfigFile(fpr,&config_file);
1194     netTest_utilParseMac(&config_file);
1196     /* parse slow path/fast path thread configuration parameters */
1197     netTest_utilParseThreadParams(&config_file);
1199     netTest_utilParseIP(&config_file);
1201     netTest_utilParseIpsecMode(&config_file);
1203     /* DSP mac processing */
1204     parse_dsp_mac(&config_file.dsp_mac[0]);
1206     /* DSP IP processing */
1207     parse_dsp_ip(&config_file.dsp_ip[0]);
1209     /* IPSEC interface number processing */
1210     parse_simple_param_u32((char*)&config_file.ipsec_if_no[0], &netTestCfg.ipsec_if_no);
1212     netTest_utilParseSA(&config_file);
1214     parse_simple_param_u32(&config_file.dest_udp_port_config, &netTestCfg.dest_udp_port_config);
1216     memset(&sa_info, 0, sizeof(sa_info));
1219 #ifdef netTest_MULTI_THREAD
1220     /* assign main net_test thread to run on core 0 */
1221     CPU_ZERO( &cpu_set);
1222     CPU_SET( 0, &cpu_set);
1223     hplib_utilSetupThread(0, &cpu_set, hplib_spinLock_Type_LOL);
1224 #endif
1226     /* create netapi */
1228     netapi_handle = netapi_init(masterType,
1229                                 &our_netapi_default_cfg);
1231     if (netapi_handle == NULL)
1232     {
1233         printf("main: netapi_init failure, exiting\n");
1234         closeRm();
1235         exit(1);
1236     }
1238     /* configure expection packet handling with netapi */
1239     netapi_netcpCfgExceptions(netapi_handle,
1240                               NETCP_CFG_ALL_EXCEPTIONS,
1241                               NETCP_CFG_ACTION_DISCARD, 
1242                               (NETCP_CFG_ROUTE_HANDLE_T) NULL);
1243     expPkt_appid = netapi_netcpCfgExceptions(netapi_handle, 
1244                                              7,
1245                                              NETCP_CFG_ACTION_TO_SW,
1246                                              (NETCP_CFG_ROUTE_HANDLE_T) NULL);
1248     /* open the main heap */
1249     ourHeap = Pktlib_findHeapByName("netapi");
1250     if (!ourHeap)
1251     {
1252         printf("Pktlib_findHeapByName()  fail\n");
1253         closeRm();
1254         exit(1);
1255     }
1257     open_pktio_tx_channels();
1259     /* create scheduler instance */
1260     our_sched =netapi_schedOpen(netapi_handle,&our_sched_cfg, &err);
1261     if (!our_sched)
1262     {
1263         printf("sched create failed\n");
1264         closeRm();
1265         exit(1);
1266     }
1269     /*create net_test MAC interfaces, attach IP to created MAC interfaces */
1270     netTest_utilCreateInterfaces(netTestCfg.num_macs, netTestCfg.num_ips);
1272     /* lookup Database for SA context, this is used by packet processing routines to get RX and TX SA information*/
1273     p_trie_sa_rx = trie_new();
1274     p_trie_sa_tx = trie_new();
1275     if (!p_trie_sa_rx || !p_trie_sa_tx)
1276     {
1277         printf("trie alloc for SA  failed\n");
1278         closeRm();
1279         exit(1);
1280     }
1282 #ifdef netTest_DSP_FASTPATH
1283     if (masterType == NETAPI_SYS_MASTER)
1284     {
1285         setup_netTestDSPFastPath(netapi_handle);
1286     }
1287 #endif
1289     netTest_utilCreateDefaultFlow(netapi_handle, masterType);
1290     /* Create RX SA's, RX Policy and TX SA's, all SA configuration parameters are read from net_test_config.txt file */
1291     netTest_utilCreateSecAssoc();
1293 #ifdef netTest_MULTI_THREAD
1295     /* create and set affinity of slow path and fast path threads to
1296     * specific CPU cores as specified in the net_test_config.txt file */
1297     netTest_utilCreateSpFpThreads(netTestCfg.num_sp_threads, 
1298                                   (NET_TEST_FUNC_PTR) slow_path_thread,
1299                                   netTestCfg.num_fp_threads,
1300                                   (NET_TEST_FUNC_PTR) fast_path_thread);
1302     printf("\n net_test_loopback running ....\n");
1303     printf("\n Enter 's' for stats or 'q'to quit net_test_loopback app, or 'h' for help\n");
1308     int c;
1309     //this thread of execution (main) now just waits on user input
1310     for(;;)
1311     {
1312        printf(">");
1313        c=getchar();
1314        if (c=='q')
1315        {
1316             QUIT=1;
1317             printf("net_test_loopback: please wait for application shutdown and resource cleanup\n");
1318             break;
1319        }
1320        else if (c=='s') netTest_utilsStatsCb(netapi_handle, &netcp_stats);
1321        else if (c=='h') printf("'q' to quit,  's' for stats, 'h' for help\n");
1322     }
1324         netTest_utilRemoveSpFpThreads(netTestCfg.num_sp_threads, netTestCfg.num_fp_threads);
1326 #else
1327     /*********************************************/
1328     /**************Entry point into scheduler ****/
1329     /*********************************************/
1330     //netTest_utilCreateSecAssoc(netcp_sb_rx_chan, netcp_sb_tx_chan,netcp_tx_chan);
1331     netapi_schedRun(our_sched, &err);
1332 #endif
1334     /* done */
1335     netTest_utilsStatsCb(netapi_handle, NULL);
1338     /* cleanup*/
1339      netTest_utilDeleteSecAssoc();
1341     netTest_utilDeleteInterfaces(netTestCfg.num_macs, netTestCfg.num_ips);
1343     /* close pktio channels we opened via open_pktio_tx_channels() */
1344     close_pktio_channels();
1345 #ifdef netTest_DSP_FASTPATH
1346     if (masterType == NETAPI_SYS_MASTER)
1347     {
1348         teardown_netTestDSPFastPath();
1349     }
1350 #endif
1352     netapi_shutdown(netapi_handle);
1353     closeRm();
1354     printf("net_test shutdown complete\n");
1358 #if 1
1359 /* Stub functions */
1360 Trie * route_init(void)
1362     return NULL;
1364 void route_add(Trie * Pt, unsigned long * Pdest_ipBE, void * Pour_route)
1367 #endif