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