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