Integrate net_test_router with RM.
[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/netapi/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];
147 /********************************************************************
148  * FUNCTION PURPOSE:  Utility function to flip and packet and send
149  *                    it back to its source.
150  ********************************************************************
151  * DESCRIPTION:   Utility function to flip and packet and send
152  *                    it back to its source.
153  ********************************************************************/
154 void flip_and_send_pkt(Ti_Pkt *tip,  unsigned char * p_pkt, int len, int flag, uint16_t enet_port)
156     unsigned char mac_temp[6];
157     unsigned char ip_temp[4];
158     unsigned char new_dest_port[2]={0x75,0x30};  // 30000
159     uint16_t dest_udp_port_config = 0;
160     uint16_t blah; 
161     uint16_t i=1;   /* for testing only */
163     uint8_t *p_spi; 
164     netTestSA_t * p_sa_info;
165     netTestSA_t *p_sa_info_tx;
166     uint8_t p_iv[16];
167     uint8_t p_add[8];
168     Cppi_HostDesc*          pPloadDesc;
169     uint8_t ah_len;
170     uint32_t tunnel_id;
171     nwalLocCxtInfo_t    nwalLocCxt;
172     netTestHead_T * p_head;
173     netTestHead_T temp_head;
174     int pkt_type;
176 #ifdef netTest_MULTI_THREAD
177     int coreid=Osal_nwalGetProcId(); //who we are(thread local)
178         //int coreid = our_core;
179 #else
180 int coreid=0;
181 #endif
182               // netTest_utilDumpBuffer((long*)p_pkt,len);
183     Pktlib_setPacketLen(tip,len);
184     //flip the mac address
185     memcpy(&mac_temp,&p_pkt[0],6);
186     memcpy(&p_pkt[0],&p_pkt[6],6);
187     memcpy(&p_pkt[6],&mac_temp,6);
188     //memcpy(&p_pkt[0],real_mac_header,6); //for testing to wireshark pc
190     //flip the ip  (outer in case of ipsec)
191     memcpy(&ip_temp, &p_pkt[netTest_MAC_HEADER_LEN+12],4);
192     memcpy(&p_pkt[netTest_MAC_HEADER_LEN+12],&p_pkt[netTest_MAC_HEADER_LEN+12+4],4);
193     memcpy(&p_pkt[netTest_MAC_HEADER_LEN+12+4],&ip_temp,4);
195     p_head=&temp_head;
197     //inner ip &udp for ipsec
198     if (flag) 
199     {
200         memcpy(p_head,&p_pkt[netTest_MAC_HEADER_LEN],sizeof(netTestHead_T));
202         if ((p_head->ip[2]&0x0000ff00)==0x00003300)
203         {
204             p_spi = &(p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN + 4]);
205             pkt_type = netTest_IPSEC_AH_PKT;
206         }
207         else if ((p_head->ip[2]&0x0000ff00)==0x00003200)
208         {
209             p_spi = &(p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN]);
210             pkt_type = netTest_IPSEC_ESP_PKT;
211         }
212         else
213         {
214             netapi_Log("flip_and_send_pkt: un-supported IPSEC protocol\n");
215             Pktlib_freePacket(tip);
216             return;
217         }
219         p_sa_info = (netTestSA_t *) trie_lookup(p_trie_sa_rx, (char *)p_spi ,4);
220         if (p_sa_info == NULL)
221         {
222             netapi_Log("flip_and_send_pkt(): trie_lookup() failed\n");
223             Pktlib_freePacket(tip);
224             return;
225         }
226         tunnel_id = p_sa_info->tunnel_id;
227         p_sa_info_tx = (netTestSA_t *) trie_lookup(p_trie_sa_tx, (char *)&tunnel_id ,4);
228         if (p_sa_info_tx == NULL)
229         {
230             netapi_Log("flip_and_send_pkt(): trie_lookup() failed\n");
231             Pktlib_freePacket(tip);
232             return;
233         }
234         //just drop non-udp packet
235         if (p_pkt[p_sa_info->tx_payload_info.encOffset+9]!=0x11)
236         {
237             stats[coreid].n_new+=1;Pktlib_freePacket(tip); return;
238         }
240         /* flip inner IP */
241         memcpy(&ip_temp, &p_pkt[p_sa_info->tx_payload_info.encOffset+12],4);
242         memcpy(&p_pkt[p_sa_info->tx_payload_info.encOffset+12],&p_pkt[p_sa_info->tx_payload_info.encOffset+12+4],4);
243         memcpy(&p_pkt[p_sa_info->tx_payload_info.encOffset+12+4],&ip_temp,4);
244         /* setting udp ports */
245         if (netTestCfg.dest_udp_port_config == 0)
246         {
247             memcpy(&p_pkt[p_sa_info->tx_payload_info.encOffset+netTest_IP_HEADER_LEN+2],
248                    &p_pkt[p_sa_info->tx_payload_info.encOffset+netTest_IP_HEADER_LEN],2);
249         }
250         else
251         {
252            dest_udp_port_config = htons(netTestCfg.dest_udp_port_config);
253             memcpy(&p_pkt[p_sa_info->tx_payload_info.encOffset+netTest_IP_HEADER_LEN+2],
254                    &dest_udp_port_config,2);
255         }
256         memset(&p_pkt[p_sa_info->tx_payload_info.encOffset+netTest_IP_HEADER_LEN+6],0,2); //checksum
258         if (netTestCfg.ipsec_mode_tx == IPSEC_MODE_TX_SIDEBAND)
259         {
260             /* inner ip checksum : leave alone, outer ip, set to 0 (we will compute on way out */
261             memset(&p_pkt[netTest_MAC_HEADER_LEN+10],0,2);
262         }
263     }
264     else
265     {
266         /* flip udp port */
267         if (netTestCfg.dest_udp_port_config == 0)
268         {
269             memcpy(&p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN+2],
270                    &p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN],2);
271         }
272         else
273         {
274             dest_udp_port_config = htons(netTestCfg.dest_udp_port_config);
275             //memcpy(&p_pkt[netTest_MAC_HEADER_LEN+20+2],&new_dest_port[0],2);
276             memcpy(&p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN+2],&dest_udp_port_config,2);
277         }
278         memset(&p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN+6],0,2);//0 udp checksum (we will compute on way out)
279     }
281     /*IPSEC case */ 
282     if (flag)
283     {
284         if (netTestCfg.ipsec_mode_tx == IPSEC_MODE_TX_SIDEBAND)
285         //send to crypto for encryption
286         //12 byte auth tag
287         {
288             PKTIO_METADATA_T meta = {PKTIO_META_SB_TX,{0},0};
289             int err;
290             nwalDmTxPayloadInfo_t meta_tx={0};
291             
292             meta.sa_handle = (void*)p_sa_info_tx->tx_tunnel;  //use TX SA APPID
294             memcpy(&meta_tx, &(p_sa_info->tx_payload_info), sizeof(nwalDmTxPayloadInfo_t));
295             meta_tx.appCtxId = (nwal_AppId)p_sa_info_tx;
296             meta_tx.encSize = len - p_sa_info->tx_payload_info.encOffset -p_sa_info->auth_tag_size;
297             meta_tx.authSize = len - meta_tx.authOffset - p_sa_info->auth_tag_size;
298             meta_tx.pAuthIV=NULL;
299             meta_tx.aadSize=0;
300             meta_tx.pAad=NULL;
301             if (p_sa_info->cipherMode ==  NWAL_SA_EALG_AES_CTR)
302             {
303                 memcpy(&p_iv[0], &p_sa_info->key_params->pEncKey[16], 4);
304                 memcpy(&p_iv[4], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
305                 p_iv[12] = 0;
306                 p_iv[13] = 0;
307                 p_iv[14] = 0;
308                 p_iv[15] = 1;
309                 meta_tx.pEncIV = &p_iv[0];
310             }
311             else if ((p_sa_info->cipherMode == NWAL_SA_EALG_AES_GCM) || (p_sa_info->cipherMode == NWAL_SA_EALG_AES_CCM))
312             {
313                 memcpy(&p_iv[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
314                 meta_tx.pEncIV = &p_iv[0];
315                 memcpy(&p_add[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN], 8);
316                 meta_tx.pAad= &p_add[0];
317                 meta_tx.aadSize = 8;
318             }
319             else if (p_sa_info->authMode == NWAL_SA_AALG_GMAC)
320             {
321                 memcpy(&p_iv[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
322                 meta_tx.pAuthIV= &p_iv[0];
323                 memcpy(&p_add[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN], 8);
324                 meta_tx.pAad= &p_add[0];
325                 meta_tx.aadSize = 8;
326             }
327             else if (p_sa_info->cipherMode ==  NWAL_SA_EALG_NULL)
328             {
329                 meta_tx.pEncIV = NULL;
330             }
331             else
332             {
333                 meta_tx.pEncIV = &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN ];
334             }
335             /* post it to netcp sb tx channel*/
336             meta.u.tx_sb_meta=&meta_tx;
338             netapi_pktioSend(netcp_sb_tx_chan,tip,&meta,&err);
339         }
340         else
341         {
342             //INFLOW TX, send pkt directly, asking for IP and UDP checksum offloads AND IPSEC to be applied
343             PKTIO_METADATA_T meta = {PKTIO_META_TX,{0},0};
344             int err;
345             nwalTxPktInfo_t meta_tx={0};
347             meta.sa_handle = (void*)p_sa_info_tx->tx_tunnel;  //use TX SA APPID
349             meta_tx.startOffset = p_sa_info_tx->tx_pkt_info.startOffset;
350             meta_tx.ipOffBytes =p_sa_info_tx->tx_payload_info.encOffset; 
351             meta_tx.l4OffBytes = p_sa_info_tx->tx_pkt_info.l4OffBytes;
352             meta_tx.l4HdrLen = p_sa_info_tx->tx_pkt_info.l4HdrLen;
353             meta_tx.ploadLen = (unsigned) ((p_pkt[meta_tx.l4OffBytes+4]<<8)|p_pkt[meta_tx.l4OffBytes+4+1]) -8 ;
354             meta_tx.saOffBytes=  p_sa_info_tx->tx_pkt_info.saOffBytes;
355             if (pkt_type == netTest_IPSEC_AH_PKT)
356             {
357                 memset(&p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN+netTest_IPSEC_AH_FIXED_HDR_SIZE],0,netTest_IPSEC_AH_FIXED_HDR_SIZE);
358                 meta_tx.txFlag1 = p_sa_info_tx->tx_pkt_info.txFlag1;
359                 meta_tx.saPayloadLen=len-netTest_MAC_HEADER_LEN;   //don't inlcude mac 
360                 meta_tx.saAhMacSize = 12;
361                 meta_tx.saAhIcvOffBytes = netTest_MAC_HEADER_LEN + netTest_IP_HEADER_LEN + netTest_IPSEC_AH_FIXED_HDR_SIZE;
362                 
363                 meta_tx.enetPort = enet_port;
364                  memcpy(&p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN+4],&p_sa_info_tx->spi,4);
365             }
366             else if (pkt_type == netTest_IPSEC_ESP_PKT)
367             {
368                 meta_tx.txFlag1 = p_sa_info_tx->tx_pkt_info.txFlag1;
369                 meta_tx.saPayloadLen=len-netTest_MAC_HEADER_LEN-netTest_IP_HEADER_LEN;   //don't include mac and ip outer header
370                 meta_tx.enetPort = 0;
371                  memcpy(&p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN],&p_sa_info_tx->spi,4);
372             }
373             else
374             {
375                 printf("flip_and_send_pkt: invalid ESP protocol\n");
376                 return;
377             }
379             meta_tx.pseudoHdrChecksum =
380             netTest_utilGetIPv4PsudoChkSum(&p_pkt[meta_tx.ipOffBytes],8+ meta_tx.ploadLen);
383             /* post it to netcp tx channel*/
384             meta.u.tx_meta=&meta_tx;
385 #ifdef DEBUG_DESC
386             if (stats[coreid].sec_tx<20) netTest_utilDumpDescr((long *) tip, stats[coreid].sec_tx);
387 #endif
388             if ( pkt_type == netTest_IPSEC_ESP_PKT)
389                 netapi_pktioSend(netcp_tx_chan_esp,tip,&meta,&err);
390             else if ( pkt_type == netTest_IPSEC_AH_PKT)
391                  netapi_pktioSend(netcp_tx_chan_ah,tip,&meta,&err);
392             stats[coreid].tx +=1;
393             stats[coreid].sec_tx +=1;
394         }
395     }
396     else  //non ipsec send pkt directly, asking for IP and UDP checksum ofload
397     {
398         PKTIO_METADATA_T meta2 = {PKTIO_META_TX,{0},0};
399         int err;
400         nwalTxPktInfo_t meta_tx2={0};
401         meta2.sa_handle=nwal_HANDLE_INVALID;
402         meta_tx2.txFlag1 = (NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID );
403         meta_tx2.startOffset = 0;
404         meta_tx2.ipOffBytes = netTest_MAC_HEADER_LEN;
405         meta_tx2.l4OffBytes = netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN;
406         meta_tx2.l4HdrLen = netTest_UDP_HEADER_LEN;
407         meta_tx2.ploadLen = (unsigned) ((p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN+4]<<8)|
408                                         p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN+4+1]) -8 ;
409         meta_tx2.pseudoHdrChecksum =
410         netTest_utilGetIPv4PsudoChkSum(&p_pkt[netTest_MAC_HEADER_LEN],8+ meta_tx2.ploadLen);
412         /* post it to netcp tx channel*/
413         meta2.u.tx_meta=&meta_tx2;
414         netapi_pktioSend(netcp_tx_chan_no_crypto,tip,&meta2,&err);
415         stats[coreid].tx +=1;
416     }
420 /**********************************************************************
421  * FUNCTION PURPOSE:  Sideband Accelerator Callback PKT RECEIVE HANDLER
422  **********************************************************************
423  * DESCRIPTION:   Sideband Accelerator Callback PKT RECEIVE HANDLER
424  *                Handles Decrypt and Encrypt operation callbacks
425  **********************************************************************/
426 void recv_sb_cb(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
427                          PKTIO_METADATA_T meta[], int n_pkts,
428                          uint64_t ts )
430     int i;
431     int len;
432     int p;
433     netTestHead_T * p_res;
434     Ti_Pkt * tip;
435     unsigned int templen;
436     int err;
437     char * p_pkt;
438     netTestHead_T * p_head;
439     netTestHead_T temp_head;
440     int tag_cmp=0;
441     unsigned int hash[4];
442     uint8_t *p_spi;
443     netTestSA_t *p_sa_info;
445 #ifdef netTest_MULTI_THREAD
446     int coreid=Osal_nwalGetProcId();  //who we are(thread local)
447 #else
448     int coreid=0;
449 #endif
450     //nwal_AppId time;
451     unsigned long time = 0;
452     unsigned long delta_time = 0;
453     /* loop over received pkts */
454     for(i=0;i<n_pkts;i++)
455    {
456         tip = p_recv[i];
457         Pktlib_getDataBuffer(tip,(uint8_t**)&p_pkt,&templen);//ignore templen
458         len = Pktlib_getPacketLen(tip);//real length
460         /*p_sa_info is for rx context */
461         p_sa_info = (netTestSA_t*)meta[i].u.rx_sb_meta->appCtxId;
462         if (p_sa_info == NULL)
463         {
464             printf("recv_sb_cb(): trie_lookup failed\n");
465             continue;
466         }
468         //is this a decrypt (rx_tunnel) complete
469         if ((int)meta[i].u.rx_sb_meta->appId == p_sa_info->rx_tunnel)
470         {
471             //time = hplib_mUtilGetPmuCCNT();
472             //delta_time = time -(unsigned long) meta[i].u.rx_sb_meta->appCtxId;
473             stats[coreid].total_decrypt_time += delta_time;
474             stats[coreid].sb_rx+=1;
475             //copy hash out of meta data (for some reason it needs endian conversion)
476             hash[0]= netTest_utilHtonl( meta[i].u.rx_sb_meta->pAuthTag[0]);
477             hash[1]= netTest_utilHtonl( meta[i].u.rx_sb_meta->pAuthTag[1]);
478             hash[2]= netTest_utilHtonl( meta[i].u.rx_sb_meta->pAuthTag[2]);
479             hash[3]= netTest_utilHtonl( meta[i].u.rx_sb_meta->pAuthTag[3]);
480             if(stats[coreid].sb_rx<=16)
481             {
482                 char *tp = (char *) &hash[0];
483                 //netTest_utilDumpHeader((long*)p_pkt, stats[coreid].sb_rx, (int)meta[i].u.rx_sb_meta->appId,0);
484             }
485             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
486             stats[coreid].n_auth_ok += !(tag_cmp);
487             flip_and_send_pkt(tip, p_pkt, len,1, 0);  //flip packet to echo back and send
488         }
489         //this is an encrypt (tx tunnel) complete
490         else if((int)meta[i].u.rx_sb_meta->appId== p_sa_info->tx_tunnel )
491         {
492             hash[0]= netTest_utilHtonl( meta[i].u.rx_sb_meta->pAuthTag[0]);
493             hash[1]= netTest_utilHtonl( meta[i].u.rx_sb_meta->pAuthTag[1]);
494             hash[2]= netTest_utilHtonl( meta[i].u.rx_sb_meta->pAuthTag[2]);
495             hash[3]= netTest_utilHtonl( meta[i].u.rx_sb_meta->pAuthTag[3]);
496             stats[coreid].sb_tx+=1;
497             if(stats[coreid].sb_tx<=16)
498             {
499                 //netTest_utilDumpHeader((long*)p_pkt, stats[coreid].sb_tx, (int)meta[i].u.rx_sb_meta->appId,0);
500             }
501             //put the computed tag in the packet
502              memcpy(&p_pkt[len-p_sa_info->auth_tag_size],(char*)&hash[0],p_sa_info->auth_tag_size); //todo, really use meta->authTagLen
503             {
504                 PKTIO_METADATA_T meta2 = {PKTIO_META_TX,{0},0};
505                 nwalTxPktInfo_t meta_tx={0};
506                 // now send directly 
507                 meta2.sa_handle=nwal_HANDLE_INVALID;
508                 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
509                 meta_tx.startOffset = 0;
510                 meta_tx.ipOffBytes = netTest_MAC_HEADER_LEN;
511                 meta_tx.l4OffBytes = 0;
512                 meta_tx.l4HdrLen = 0;
513                 meta_tx.ploadLen = 0;
514                 time = hplib_mUtilGetPmuCCNT();
515                 delta_time = time -(unsigned long) meta[i].u.rx_sb_meta->appCtxId;
516                 stats[coreid].total_encrypt_time += delta_time;
518                 /* post it to netcp tx channel*/
519                 meta2.u.tx_meta=&meta_tx;
520                 netapi_pktioSend(netcp_tx_chan_no_crypto,tip,&meta2,&err);
521                 //netapi_pktioSend(netcp_tx_chan_esp,tip,&meta2,&err);
522                 hplib_cacheWbInv(p_pkt,len);
523                 stats[coreid].tx +=1;
524             }
525         }
526         else printf("netapi recv_sb_cb: unknown appiD %x \n",meta[i].u.rx_sb_meta->appId );
527     }
530 /**********************************************************************
531  * FUNCTION PURPOSE:  Packet receive Callback
532  *
533  **********************************************************************
534  * DESCRIPTION:   packet Receive callback
535  **********************************************************************/
536 void recv_cb(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
537                          PKTIO_METADATA_T meta[], int n_pkts,
538                          uint64_t ts )
540     int i;
541     int len;
542     int p;
543     netTestHead_T * p_res;
544     Ti_Pkt * tip;
545     unsigned int templen;
546     int err = 0;
547     char * p_pkt;
548     netTestHead_T * p_head;
549     netTestHead_T temp_head;
550     netTestSA_t *p_sa_info;
551     uint8_t *p_spi;
552     uint8_t p_iv[16];
553     uint8_t p_add[8];
554     uint8_t p_add1[1500];
555     int16_t       retVal;
556     unsigned long t1;
557     unsigned long t2;
558     unsigned long long ct1;
559     unsigned long long ct2;
560     unsigned long long n_c_ops;
561     nwalGlobCxtInfo_t   nwalGlobCxt;
562     nwalLocCxtInfo_t    nwalLocCxt;
564     Cppi_HostDesc*          pPloadDesc;
565     int ifno;
566     uint16_t enet_port = 0;
568 #ifdef netTest_MULTI_THREAD
569     int coreid=Osal_nwalGetProcId();  //who we are(thread local)
570 #else
571     int coreid=0;
572 #endif
573     p_head=&temp_head;
575     t1=hplib_mUtilGetPmuCCNT();
576     ct1 =Osal_cache_op_measure(&n_c_ops);
578     /* loop over received pkts */
579     for(i=0;i<n_pkts;i++)
580     {
581         ifno = ((unsigned int)meta[i].u.rx_meta->appId)&0xff;
582         
583         enet_port = meta[i].u.rx_meta->enetPort;
584         tip = p_recv[i];
586         Pktlib_getDataBuffer(tip,(uint8_t**)&p_pkt,&templen);/*ignore templen */
587         len = Pktlib_getPacketLen(tip)-4;   /*real length, subtract mac trailer */
588         Cppi_setData (Cppi_DescType_HOST, (Cppi_Desc *) tip, p_pkt,len);
589         Pktlib_setPacketLen(tip,len);
591         if(((unsigned int)meta[i].u.rx_meta->appId) == expPkt_appid)
592         {
593             netapi_Log("recv_cb: received exception packet\n");
594             Pktlib_freePacket(tip);
595             if(((unsigned int)meta[i].u.rx_meta->rxFlag1  & NWAL_RX_IP_FRAGMENT_PKT) ==
596                                              NWAL_RX_IP_FRAGMENT_PKT)
597             {
598                 stats[coreid].exceptionPktsFrag+=1;
599             }
600             else
601             {
602                 stats[coreid].exceptionPktsOther+=1;
603             }
604             continue;
605         }
606         //debug: validate descriptor */
607         if(Pktlib_getNextPacket(tip) != 0) 
608         {
609             printf(" rcv_cb, nexpkt != NULL");
610         }
612         if(coreid<TUNE_NETAPI_NUM_CORES)
613         {
614             stats[coreid].rx+=1;
615             if (ifno < TUNE_NETAPI_MAX_NUM_MAC)
616                 stats[coreid].if_rx[ifno]+=1;
617         }
619 #ifdef DEBUG_DESC
620         if(coreid<TUNE_NETAPI_NUM_CORES)
621         {
622             if (stats[coreid].rx<16)
623             {
624                 netapi_Log(">rx dmp.."); 
625                 netTest_utilDumpDescr((long *) tip, stats[coreid].rx);
626             }
627             else if (stats[coreid].rx>99) 
628             {
629                 netapi_Log(">rx dmp.."); 
630                 netTest_utilDumpDescr((long *) tip,stats[coreid].rx);
631             }
632         }
633 #endif
634 #if 0
635         //
636         if(stats[coreid].rx<=16)
637         {
638             netTest_utilDumpHeader((long*)p_pkt,stats[coreid].rx, (int)meta[i].u.rx_meta->appId,meta[i].u.rx_meta->rxFlag1);
639             netTest_utilDumpBuffer((long*)p_pkt,len);
640         }
641 #endif
642         /* check header */
643         memcpy(p_head,&p_pkt[netTest_MAC_HEADER_LEN],sizeof(netTestHead_T));
645         /* check for IPSEC ESP or AH packet, 0x32 is ESP tunnel mode, 0x33 is AH tunnel mode*/
646         if (((p_head->ip[2]&0x0000ff00)==0x00003200) || ((p_head->ip[2]&0x0000ff00)==0x00003300))
647         {
648             if (!netTest_utilCheckHeader(p_head,&meta[i]))
649             {
650                 printf("recv_cb: error in ipsec pkt\n");
651                 stats[coreid].n_bad+=1;Pktlib_freePacket(tip); 
652                 continue;
653             }
655             //process IP SEC PACKET
656             if (netTestCfg.ipsec_mode_rx == IPSEC_MODE_RX_SIDEBAND)
657             {
658                 p_spi = &(p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN]);
659                 p_sa_info = (netTestSA_t *) trie_lookup(p_trie_sa_rx, (char *)p_spi ,4);
660                 if (p_sa_info == NULL)
661                 {
662                     printf("recv_cb(): trie_lookup() failed\n");
663                     continue;
664                 }
666                 //ship to crypto for decrypt!!
667                 //12 byte auth tag
668                 PKTIO_METADATA_T meta2 = {PKTIO_META_SB_TX,{0},0};
669                 nwalDmTxPayloadInfo_t meta_tx={0};
671                 meta2.sa_handle = (void*) p_sa_info->rx_tunnel;
673                 memcpy(&meta_tx, &(p_sa_info->tx_payload_info), sizeof(nwalDmTxPayloadInfo_t));
675                 meta_tx.encSize = len - p_sa_info->tx_payload_info.encOffset -p_sa_info->auth_tag_size;
676                 meta_tx.authSize = len - meta_tx.authOffset - p_sa_info->auth_tag_size;
678                 if (p_sa_info->cipherMode == NWAL_SA_EALG_AES_CTR)
679                 {
680                     memcpy(&p_iv[0], &p_sa_info->key_params->pEncKey[16], 4);
681                     memcpy(&p_iv[4], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
682                     p_iv[12] = 0;
683                     p_iv[13] = 0;
684                     p_iv[14] = 0;
685                     p_iv[15] = 1;
686                     meta_tx.pEncIV = &p_iv[0];
687                  
688                 }
689                 else if ((p_sa_info->cipherMode == NWAL_SA_EALG_AES_GCM) ||
690                             (p_sa_info->cipherMode == NWAL_SA_EALG_AES_CCM))
691                 {
692                         memcpy(&p_iv[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
693                         meta_tx.pEncIV = &p_iv[0];
694                         /* aad is the ESP header which is 8 bytes */
695                         memcpy(&p_add[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN], 8);
696                         meta_tx.pAad= &p_add[0];
697                         meta_tx.aadSize = 8;
698                 }
699                 else if (p_sa_info->authMode == NWAL_SA_AALG_GMAC)
700                 {
701                     memcpy(&p_iv[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
702                         meta_tx.pAuthIV= &p_iv[0];
703                         /* aad is the ESP header which is 8 bytes */
704                         memcpy(&p_add[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN], 8);
705                         meta_tx.pAad= &p_add[0];
706                         meta_tx.aadSize = 8;
707                 }
708                 else if (p_sa_info->cipherMode ==  NWAL_SA_EALG_NULL)
709                 {
710                     meta_tx.pEncIV = NULL;
711                 }
712                 else
713                 {
714                     meta_tx.pEncIV = &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN ];
715                 }
716                
717                 meta_tx.appCtxId = (nwal_AppId)p_sa_info;
719                 /* post it to netcp sb tx channel*/
720                 meta2.u.tx_sb_meta=&meta_tx;
722                 netapi_pktioSend(netcp_sb_tx_chan,tip,&meta2,&err);
723                 continue;
724             }
725             else
726             {
727                 //inflow mode.  flip and send
728                 flip_and_send_pkt(tip,p_pkt,len,1, enet_port);
729             }
730         }
731         /* check for udp protocol */
732         else if ((p_head->ip[2]&0x0000ff00)!=0x00001100)
733          //else if ((p_head->ip[2]&0x00ff0000)!=0x00110000)
734         {
735             stats[coreid].n_new+=1;Pktlib_freePacket(tip); continue;
736         }
737         else  //non ipsec
738         {
739             if (!netTest_utilCheckHeader(p_head,&meta[i]))
740             {
741                 stats[coreid].n_bad+=1;Pktlib_freePacket(tip);
742                 continue;
743             }
744             //just flip and send
745             flip_and_send_pkt(tip,p_pkt,len,0, enet_port);
746         }
747     }
748     t2=hplib_mUtilGetPmuCCNT();
749     ct2 =Osal_cache_op_measure(&n_c_ops);
750     stats[coreid].app_cycles +=  (unsigned long long) (t2-t1);
751     stats[coreid].tx_cache_cycles += (unsigned long long) (ct2-ct1);
754 /* Templates to build command labels at startup up time, required by open_pktio_tx_channels() */
755 nwalTxPktInfo_t txPktInfoESP = 
757     NULL,                                                                                               /* p_pkt */
758     NWAL_TX_FLAG1_DO_IPSEC_ESP_CRYPTO| NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID,      /* txFlags */
759     0,                                                                                                  /* lpbackPass */
760     0,                                                                                                  /* enetport */
761     0,                                                                                                  /* msuSize */
762     0,                                                                                                   /* startOffset */
763     netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN,                                                    /* saOffBytes */
764     0,                                                                                                  /* saPayLoadLen */
765     0               ,                                                                                    /* saAhIcvOffBytes */
766     0,                                                                                                 /* saAhMacSize */
767     0,                                                                                                  /* etherLenOffBytes */
768     0,                                                                                                  /* ipOffBytes */
769     0,                                                                                                  /* l4OffBytes */
770     netTest_UDP_HEADER_LEN,                                                                             /* l4HdrLen */
771     0,                                                                                                  /* pseudoHdrChecksum */
772     0                                                                                                   /* pLoadLen */
773 };
776 nwalTxPktInfo_t txPktInfoAH = 
778     NULL,                                                                                               /* p_pkt */
779     NWAL_TX_FLAG1_DO_IPSEC_AH_CRYPTO| NWAL_TX_FLAG1_DO_UDP_CHKSUM | NWAL_TX_FLAG1_META_DATA_VALID,      /* txFlags */
780     0,                                                                                                  /* lpbackPass */
781     0,                                                                                                  /* enetport */
782     0,                                                                                                  /* msuSize */
783     0,                                                                                                   /* startOffset */
784     netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN,                                                    /* saOffBytes */
785     0,                                                                                                  /* saPayLoadLen */
786     netTest_MAC_HEADER_LEN + netTest_IP_HEADER_LEN + netTest_IPSEC_AH_FIXED_HDR_SIZE,                    /* saAhIcvOffBytes */
787     12,                                                                                                 /* saAhMacSize */
788     0,                                                                                                  /* etherLenOffBytes */
789     0,                                             /* ipOffBytes */
790     0,                                                                                                  /* l4OffBytes */
791     netTest_UDP_HEADER_LEN,                                                                            /* l4HdrLen */
792     0,                                                                                                  /* pseudoHdrChecksum */
793     0                                                                                                   /* pLoadLen */
794 };
796 nwalTxPktInfo_t txPktInfoNoCrypto = 
798     NULL,                                                                                               /* p_pkt */
799     NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID,      /* txFlags */
800     0,                                                                                                  /* lpbackPass */
801     0,                                                                                                  /* enetport */
802     0,                                                                                                  /* msuSize */
803     0,                                                                                                   /* startOffset */
804     0,                                                    /* saOffBytes */
805     0,                                                                                                  /* saPayLoadLen */
806     0               ,                                                                                    /* saAhIcvOffBytes */
807     0,                                                                                                 /* saAhMacSize */
808     0,                                                                                                  /* etherLenOffBytes */
809     0,                                                                                                  /* ipOffBytes */
810     netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN,                                        /* l4OffBytes */
811     netTest_UDP_HEADER_LEN,                                                             /* l4HdrLen */
812     0,                                                                         /* pseudoHdrChecksum */
813     0                                                                                                   /* pLoadLen */
814 };
817 void close_pktio_channels(void)
819     int err;
820     netapi_pktioClose(netcp_tx_chan_esp ,&err);
821     netapi_pktioClose(netcp_tx_chan_ah ,&err);
822     netapi_pktioClose(netcp_sb_tx_chan ,&err);
823     netapi_pktioClose(netcp_tx_chan_no_crypto,&err);
826 void open_pktio_tx_channels(void)
828     int err;
829     /* open netcp default  TX for ESP packets */
830     netcp_tx_chan_esp= netapi_pktioOpen(netapi_handle, NETCP_TX, NULL, &netcp_tx_cfg,  &err);
831     if (!netcp_tx_chan_esp)
832     {
833         printf("pktio open TX failed err=%d\n",err);
834         exit(1);
835     }
836     else
837     {
838         if(netTestCfg.ipsec_mode_tx == IPSEC_MODE_TX_INFLOW)
839         {
840             PKTIO_CONTROL_T control;
841             control.op = PKTIO_UPDATE_FAST_PATH;
842             PKTIO_CFG_T cfg;
843             cfg.fast_path_cfg.fp_send_option = PKTIO_FP_ESP_L4CKSUM_PORT;
844             cfg.fast_path_cfg.txPktInfo= &txPktInfoESP;
845             netapi_pktioControl(netcp_tx_chan_esp, NULL, &cfg, &control, &err);
846         }
847     }
849     /*/* open netcp default  TX for AH packets */
850     netcp_tx_chan_ah= netapi_pktioOpen(netapi_handle, NETCP_TX, NULL, &netcp_tx_cfg,  &err);
851     if (!netcp_tx_chan_ah)
852     {
853         printf("pktio open TX failed err=%d\n",err);
854         exit(1);
855     }
856     else
857     {
858         if(netTestCfg.ipsec_mode_tx == IPSEC_MODE_TX_INFLOW)
859         {
860             PKTIO_CONTROL_T control;
861             control.op = PKTIO_UPDATE_FAST_PATH;
862             PKTIO_CFG_T cfg;
863             cfg.fast_path_cfg.fp_send_option = PKTIO_FP_AH_L4CKSUM_PORT;
864             cfg.fast_path_cfg.txPktInfo= &txPktInfoAH;
865             netapi_pktioControl(netcp_tx_chan_ah, NULL, &cfg, &control, &err);
866         }
867     }
869     /* open netcp default  TX channels for non-Crypto packets */
870     netcp_tx_chan_no_crypto= netapi_pktioOpen(netapi_handle, NETCP_TX, NULL, &netcp_tx_cfg,  &err);
871     if (!netcp_tx_chan_no_crypto)
872     {
873         printf("pktio open TX failed err=%d\n",err);
874         exit(1);
875     }
876     else
877     {
878         if(netTestCfg.ipsec_mode_tx == IPSEC_MODE_TX_INFLOW)
879         {
880             PKTIO_CONTROL_T control;
881             control.op = PKTIO_UPDATE_FAST_PATH;
882             PKTIO_CFG_T cfg;
883             cfg.fast_path_cfg.fp_send_option = PKTIO_FP_L4CKSUM_PORT;
884             cfg.fast_path_cfg.txPktInfo= &txPktInfoNoCrypto;
885             netapi_pktioControl(netcp_tx_chan_no_crypto, NULL, &cfg, &control, &err);
886         }
887     }
889     /* open netcp default  TX channels for SB crypto */
890     netcp_sb_tx_chan= netapi_pktioOpen(netapi_handle, NETCP_SB_TX, NULL, &netcp_sb_tx_cfg,  &err);
891     if (!netcp_sb_tx_chan)
892     {
893         printf("pktio open SB TX failed err=%d\n",err);
894         exit(1);
895     }
898 #ifdef netTest_DSP_FASTPATH
899 void setup_netTestDSPFastPath(NETAPI_T handle)
902     int i;
903     int err = 0;
904     PKTIO_CFG_T dsp_pktio_cfg;
905     NETCP_CFG_CLASSIFIER_T dsp_classi;
906     NETCP_CFG_ROUTE_T dsp_route;
908     memset(&dsp_pktio_cfg, 0, sizeof (PKTIO_CFG_T));
909     memset(&dsp_classi, 0, sizeof (NETCP_CFG_CLASSIFIER_T));
910     memset(&dsp_route, 0, sizeof (NETCP_CFG_ROUTE_T));
911     char dsp_name[32];
912     for (i = 0; i < CPU_NUM_REM_FAST_PATH_CORES; i++)
913     {
914         snprintf(&dsp_name[0],32, "%s%d","dsp_chan", i);
915         dsp_pktio_cfg.flags1 = PKTIO_RX;
916         dsp_pktio_cfg.flags2 = PKTIO_GLOBAL | PKTIO_PKT;
917         dsp_pktio_cfg.qnum = TEST_NWAL_BASE_REM_FP_RX_PKT_QUEUE + i;
918         dsp_pktio_cfg.max_n = 8;
920         /* pktio channels created here will NOT be POLLED by net_test arm application */
921         dsp_pktio_channels[i] = netapi_pktioCreate(handle,
922                                                &dsp_name[0],
923                                                (PKTIO_CB)recv_cb,
924                                                &dsp_pktio_cfg,
925                                                &err);
926         if (!dsp_pktio_channels[i])
927         {
928             netapi_Log("setup_netTestDSPFastPath: failed for core %d\n", i);
929         }
931         dsp_classi.classType =NETCP_CFG_CLASS_TYPE_L4;
932         dsp_classi.u.c_l4.iface = netTestCfg.dsp_mac;
933         
934         dsp_classi.u.c_l4.ip = ip_rule[netTestCfg.dsp_ip];
935         dsp_classi.u.c_l4.proto = NWAL_APP_PLOAD_PROTO_UDP;
936         dsp_classi.u.c_l4.appProto.udpPort = TEST_NWAL_BASE_REM_FP_UDP_PORT + i;
938         dsp_route.p_dest_q = dsp_pktio_channels[i];
939        
940         dsp_route.p_flow = (NETCP_CFG_FLOW_T*)NETCP_DEFAULT_FLOW;
941         
942         dsp_classifers[i] = netapi_netcpCfgAddClass(handle, 
943                                 &dsp_classi, 
944                                 (NETCP_CFG_ROUTE_HANDLE_T) &dsp_route, 
945                                 NETCP_CFG_ACTION_TO_SW,
946                                 NULL,
947                                 &err);
949         if (err != NETAPI_ERR_OK)
950         {
951             netapi_Log("setup_netTestDSPFastPath: netapi_netcpCfgAddClass failed for core %d\n", i);
952         }
953     }
954     printf("DSP Path fath setup complete\n");
957 void teardown_netTestDSPFastPath()
959     int i;
960     int err=0;
962     for (i = 0; i < CPU_NUM_REM_FAST_PATH_CORES; i++)
963     {
964         netapi_netcpCfgDelClass(netapi_handle,
965                                 dsp_classifers[i],
966                                 &err);
967         if (err != NETAPI_ERR_OK)
968         {
969             printf("teardown_netTestDSPFastPath: netapi_netcpCfgDelClass failed for core %d\n", i);
970         }
972         netapi_pktioDelete(dsp_pktio_channels[i],
973                            &err);
974         if (err != NETAPI_ERR_OK)
975         {
976             printf("teardown_netTestDSPFastPath: netapi_pktioDelete failed for core %d\n", i);
977         }
978     }
979     printf("DSP Path fath teardown complete\n");
981 #endif
984 #ifdef netTest_MULTI_THREAD
985 NETAPI_T worker_nh[TUNE_NETAPI_NUM_CORES];
987 void slow_path_thread(uint32_t index)
989     int err, i;;
990     uint32_t thread_num;
991     PKTIO_HANDLE_T *rx_chan;
992     PKTIO_HANDLE_T *sb_rx_chan;
995     cpu_set_t cpu_set;
997     thread_num = netTestCfg.sp_thread_num[index];
998     netapi_Log("slow_path_thread, mypid: %d, core_id %d\n", gettid(), netTestCfg.sp_thread_num[index]);
1000     CPU_ZERO( &cpu_set);
1001 #ifdef CORTEX_A8
1002     for (i = netTestCfg.sp_proc_start[index]; i <= netTestCfg.sp_proc_end[index];i++)
1003     {
1004         printf("slow_path_thread: setting cpu %d to cpu_set\n", i);
1005         CPU_SET( 0, &cpu_set);
1006     }
1007     hplib_utilSetupThread(thread_num, &cpu_set, hplib_spinLock_Type_LOL);
1008 #else
1009     for (i = netTestCfg.sp_proc_start[index]; i <= netTestCfg.sp_proc_end[index];i++)
1010     {
1011         CPU_SET( i, &cpu_set);
1012     }
1013     hplib_utilSetupThread(thread_num, &cpu_set, hplib_spinLock_Type_LOL);
1014 #endif
1015     worker_nh[thread_num] = netapi_init(NETAPI_CORE_MASTER,NULL);
1017     if (worker_nh[thread_num] == NULL)
1018     {
1019         printf("slow_path_thread: netapi_init failure, exiting\n");
1020         exit(1);
1021     }
1022     netapi_setCookie(worker_nh[thread_num],(void*)(thread_num | NET_TEST_SP_THREAD_MASK));
1024     scheduler[thread_num] =netapi_schedOpen(worker_nh[thread_num],&our_sched_cfg, &err);
1025     if (!scheduler[thread_num]) 
1026     {
1027         printf("sched create failed for core%d\n",thread_num);
1028         goto ERR_slow_path_thread;
1029     }
1030     scheduler[thread_num]->config.yield = NETAPI_TRUE;
1031     scheduler[thread_num]->config.pollGarbageQ = NETAPI_TRUE;
1032     scheduler[thread_num]->config.pollCtrlQ = NETAPI_TRUE;
1033     printf("Slow Path thread: %d setup complete, running on ARM CORE: %d\n", i,i);
1034     /* Entry point to scheduler */
1035     netapi_schedRun(scheduler[thread_num], &err);
1037 ERR_slow_path_thread:
1038     printf("slow_path_thread: calling netapi_shutdown\n");
1039     netapi_shutdown(worker_nh[thread_num]);
1042 void fast_path_thread(uint32_t index)
1044     int err, i;
1045     PKTIO_HANDLE_T *rx_chan;
1046     PKTIO_HANDLE_T *sb_rx_chan;
1047     uint32_t thread_num;
1050     cpu_set_t cpu_set;
1052     CPU_ZERO( &cpu_set);
1053     thread_num = netTestCfg.fp_thread_num[index];
1054 #ifdef CORTEX_A8
1055     for (i = netTestCfg.fp_proc_start[index]; i <= netTestCfg.fp_proc_end[index];i++)
1056     {
1057         CPU_SET( 0, &cpu_set);
1058     }
1059     hplib_utilSetupThread(thread_num, &cpu_set, hplib_spinLock_Type_LOL);
1060 #else
1061     for (i = netTestCfg.fp_proc_start[index]; i <= netTestCfg.fp_proc_end[index];i++)
1062     {
1063         netapi_Log("fast_path_thread: start core %d end core %d\n",
1064                 netTestCfg.fp_proc_start[index],
1065                 netTestCfg.fp_proc_end[index]);
1066         netapi_Log("fast_path_thread: setting cpu %d to cpu_set\n", i);
1067         CPU_SET( i, &cpu_set);
1068     }
1069     hplib_utilSetupThread(thread_num, &cpu_set, hplib_spinLock_Type_LOL);
1070 #endif
1071     hplib_mSpinLockLock(&net_test_thread_lock);
1072     worker_nh[thread_num]=netapi_init(NETAPI_CORE_MASTER,NULL);
1073     
1074     if (worker_nh[thread_num] == NULL)
1075     {
1076         printf("fast_path_thread: netapi_init failure, exiting\n");
1077         hplib_mSpinLockUnlock(&net_test_thread_lock);
1078         exit(1);
1079     }
1080     hplib_mSpinLockUnlock(&net_test_thread_lock);
1081     /* open netcp default RX channels*/
1082     rx_chan = netapi_pktioOpen(worker_nh[thread_num], NETCP_RX, (PKTIO_CB) recv_cb, &netcp_rx_cfg,  &err);
1084     /* create a pktio channel for specially classified pkts */
1085     /* open netcp default tx, rx queues for sideband crypto */
1086     sb_rx_chan = netapi_pktioOpen(worker_nh[thread_num], NETCP_SB_RX, (PKTIO_CB) recv_sb_cb, &netcp_sb_rx_cfg,  &err);
1088     netapi_setCookie(worker_nh[thread_num],(void*)thread_num);
1089     
1090     scheduler[thread_num] =netapi_schedOpen(worker_nh[thread_num],&our_sched_cfg, &err);
1091     if (!scheduler[thread_num]) 
1092         {
1093         printf("sched create failed for core%d\n",thread_num);
1094         goto ERR_fast_path_thread;
1095         //exit(1);
1096     }
1098  
1099     scheduler[thread_num]->config.yield = NETAPI_FALSE;
1100     scheduler[thread_num]->config.pollGarbageQ = NETAPI_FALSE;
1101     scheduler[thread_num]->config.pollCtrlQ = NETAPI_FALSE;
1102      //sleep(100000);
1103    /* Entry point to scheduler */
1104     printf("Fast Path thread: %d setup complete, running on ARM CORE: %d\n", i,i);
1105     netapi_schedRun(scheduler[thread_num], &err);
1107 ERR_fast_path_thread:
1108     netapi_pktioClose(rx_chan, &err);
1109     netapi_pktioClose(sb_rx_chan, &err);
1110     
1111     printf("fast_path_thread: calling netapi_shutdown\n");
1112     netapi_shutdown(worker_nh[thread_num]);
1115 #endif
1116 /***************************************
1117  ********** test driver*****************
1118  ***************************************/
1119 int main(int argc, char **argv)
1121     int err,i;
1122     Pktlib_HeapCfg      heapCfg;
1123     int32_t             errCode;
1124     Pktlib_HeapIfTable*  pPktifTable;
1125     FILE * fpr = NULL;
1127 #ifdef netTest_MULTI_THREAD
1128     cpu_set_t cpu_set;
1129 #endif
1130      /* install signal handler for ^c */
1131     signal(SIGINT,netTest_utilMySig);
1133     if (argc == 2)
1134     {
1135         printf("main: filename1 %s\n", argv[1]);
1136         fpr = fopen(argv[1], "r");
1137     }
1138     else
1139     {
1140         fpr = fopen(input_file_name, "r");
1141     }
1142     if (fpr == NULL)
1143     {
1144         printf("Cant open config file: filepath %s, %s\n", input_file_name, strerror(errno));
1145         exit(1);
1146     }
1148     if (initRm())
1149     {
1150         printf("main: initRm() returned error\n");
1151         exit(1);
1152     }
1153     hplib_mSpinLockInit(&net_test_thread_lock );
1154     our_netapi_default_cfg.rmHandle = rmClientServiceHandle;
1155     memset(&config_file, 0, sizeof(netTestConfigFile_t));
1156     memset(&netTestCfg, 0, sizeof(netTestConfig_t));
1158     netTest_utilProcessConfigFile(fpr,&config_file);
1160     netTest_utilParseMac(&config_file);
1162     /* parse slow path/fast path thread configuration parameters */
1163     netTest_utilParseThreadParams(&config_file);
1165     netTest_utilParseIP(&config_file);
1167     netTest_utilParseIpsecMode(&config_file);
1169     /* DSP mac processing */
1170     parse_dsp_mac(&config_file.dsp_mac[0]);
1172     /* DSP IP processing */
1173     parse_dsp_ip(&config_file.dsp_ip[0]);
1175     /* IPSEC interface number processing */
1176     parse_simple_param_u32((char*)&config_file.ipsec_if_no[0], &netTestCfg.ipsec_if_no);
1178     netTest_utilParseSA(&config_file);
1180     parse_simple_param_u32(&config_file.dest_udp_port_config, &netTestCfg.dest_udp_port_config);
1182     memset(&sa_info, 0, sizeof(sa_info));
1185 #ifdef netTest_MULTI_THREAD
1186     /* assign main net_test thread to run on core 0 */
1187     CPU_ZERO( &cpu_set);
1188     CPU_SET( 0, &cpu_set);
1189     hplib_utilSetupThread(0, &cpu_set, hplib_spinLock_Type_LOL);
1190 #endif
1192     /* create netapi */
1194     netapi_handle = netapi_init(NETAPI_SYS_MASTER,
1195                                 &our_netapi_default_cfg);
1197     if (netapi_handle == NULL)
1198     {
1199         printf("main: netapi_init failure, exiting\n");
1200         closeRm();
1201         exit(1);
1202     }
1204     /* configure expection packet handling with netapi */
1205     netapi_netcpCfgExceptions(netapi_handle,
1206                               NETCP_CFG_ALL_EXCEPTIONS,
1207                               NETCP_CFG_ACTION_DISCARD, 
1208                               (NETCP_CFG_ROUTE_HANDLE_T) NULL);
1209     expPkt_appid = netapi_netcpCfgExceptions(netapi_handle, 
1210                                              7,
1211                                              NETCP_CFG_ACTION_TO_SW,
1212                                              (NETCP_CFG_ROUTE_HANDLE_T) NULL);
1214     /* open the main heap */
1215     ourHeap = Pktlib_findHeapByName("netapi");
1216     if (!ourHeap)
1217     {
1218         printf("Pktlib_findHeapByName()  fail\n");
1219         closeRm();
1220         exit(1);
1221     }
1223     open_pktio_tx_channels();
1225     /* create scheduler instance */
1226     our_sched =netapi_schedOpen(netapi_handle,&our_sched_cfg, &err);
1227     if (!our_sched)
1228     {
1229         printf("sched create failed\n");
1230         closeRm();
1231         exit(1);
1232     }
1235     /*create net_test MAC interfaces, attach IP to created MAC interfaces */
1236     netTest_utilCreateInterfaces(netTestCfg.num_macs, netTestCfg.num_ips);
1238     /* lookup Database for SA context, this is used by packet processing routines to get RX and TX SA information*/
1239     p_trie_sa_rx = trie_new();
1240     p_trie_sa_tx = trie_new();
1241     if (!p_trie_sa_rx || !p_trie_sa_tx)
1242     {
1243         printf("trie alloc for SA  failed\n");
1244         closeRm();
1245         exit(1);
1246     }
1248 #ifdef netTest_DSP_FASTPATH
1249     setup_netTestDSPFastPath(netapi_handle);
1250 #endif
1252     /* Create RX SA's, RX Policy and TX SA's, all SA configuration parameters are read from net_test_config.txt file */
1253     netTest_utilCreateSecAssoc();
1255 #ifdef netTest_MULTI_THREAD
1257     /* create and set affinity of slow path and fast path threads to
1258     * specific CPU cores as specified in the net_test_config.txt file */
1259     netTest_utilCreateSpFpThreads(netTestCfg.num_sp_threads, 
1260                                   (NET_TEST_FUNC_PTR) slow_path_thread,
1261                                   netTestCfg.num_fp_threads,
1262                                   (NET_TEST_FUNC_PTR) fast_path_thread);
1264     printf("\n net_test_loopback running ....\n");
1265     printf("\n Enter 's' for stats or 'q'to quit net_test_loopback app, or 'h' for help\n");
1270     int c;
1271     //this thread of execution (main) now just waits on user input
1272     for(;;)
1273     {
1274        printf(">");
1275        c=getchar();
1276        if (c=='q')
1277        {
1278             QUIT=1;
1279             printf("net_test_loopback: please wait for application shutdown and resource cleanup\n");
1280             break;
1281        }
1282        else if (c=='s') netTest_utilsStatsCb(netapi_handle, &netcp_stats);
1283        else if (c=='h') printf("'q' to quit,  's' for stats, 'h' for help\n");
1284     }
1286         netTest_utilRemoveSpFpThreads(netTestCfg.num_sp_threads, netTestCfg.num_fp_threads);
1288 #else
1289     /*********************************************/
1290     /**************Entry point into scheduler ****/
1291     /*********************************************/
1292     //netTest_utilCreateSecAssoc(netcp_sb_rx_chan, netcp_sb_tx_chan,netcp_tx_chan);
1293     netapi_schedRun(our_sched, &err);
1294 #endif
1296     /* done */
1297     netTest_utilsStatsCb(netapi_handle, NULL);
1300     /* cleanup*/
1301      netTest_utilDeleteSecAssoc();
1303     netTest_utilDeleteInterfaces(netTestCfg.num_macs, netTestCfg.num_ips);
1305     /* close pktio channels we opened via open_pktio_tx_channels() */
1306     close_pktio_channels();
1307 #ifdef netTest_DSP_FASTPATH
1308     teardown_netTestDSPFastPath();
1309 #endif
1311     netapi_shutdown(netapi_handle);
1312     closeRm();
1313     printf("net_test shutdown complete\n");
1317 #if 1
1318 /* Stub functions */
1319 Trie * route_init(void)
1321     return NULL;
1323 void route_add(Trie * Pt, unsigned long * Pdest_ipBE, void * Pour_route)
1326 #endif