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