NETAPI library and test changes to integrate with Resource Manager(RM)
authorTinku Mannan <tmannan@ti.com>
Wed, 14 May 2014 18:04:43 +0000 (14:04 -0400)
committerTinku Mannan <tmannan@ti.com>
Wed, 14 May 2014 18:05:13 +0000 (14:05 -0400)
18 files changed:
ti/runtime/netapi/netcp_cfg.h
ti/runtime/netapi/pktio.h
ti/runtime/netapi/src/netapi.c
ti/runtime/netapi/src/netapi_init.c
ti/runtime/netapi/src/netapi_loc.h
ti/runtime/netapi/src/pdkv2/netapi_navig.c
ti/runtime/netapi/src/pdkv3/netapi_navig.c
ti/runtime/netapi/src/pktio.c
ti/runtime/netapi/test/build/Makefile
ti/runtime/netapi/test/ifdma_test.c
ti/runtime/netapi/test/net_test_bench.c
ti/runtime/netapi/test/net_test_loopback.c
ti/runtime/netapi/test/net_test_max_params.c
ti/runtime/netapi/test/net_test_router.c
ti/runtime/netapi/utils/netapi_util_rm.c [new file with mode: 0755]
ti/runtime/netapi/utils/sockrmmsg.h [new file with mode: 0755]
ti/runtime/netapi/utils/sockutils.c [new file with mode: 0755]
ti/runtime/netapi/utils/sockutils.h [new file with mode: 0755]

index cddd5cd2f1fd932e6021338f9f14120785b56854..9115f3ad51a25ecc252e59a8ebd61b0632c53395 100755 (executable)
@@ -88,6 +88,7 @@ typedef struct NETAPI_CFG_Tag
  int def_heap_tailroom_size;        /**<  Size of tailroom in reserve */
  int def_heap_extra_size;           /**<  Size of extra space at end of buffer */ 
  int def_multi_process;             /**<  Flag to indicate if NETAPI init is for multi-process environment */
+ void *rmHandle;                    /**<  Optional: Resource Manager (RM) server handle to use RM for re                                                    souce allocations*/
 }  NETAPI_CFG_T;
 
 /* @note:
index b4f1cb72ceb51b1923f1b620554246fbda92f47d..7302b61bf34beb8e52d8a36ff208a5fef18c4f8e 100755 (executable)
@@ -335,6 +335,8 @@ typedef struct PKTIO_CFG_Tag
     int qnum;       /**< PKTIO channel queue number */
     int max_n;      /**< Maximum number of packets read in 1 poll */
     PKTIO_FAST_PATH_CONFIG_T fast_path_cfg;  /** < @ref PKTIO_FAST_PATH_CONFIG_T */
+    int queueType ;             /**<Queue Manager queue type,
+                                    refer to ti/csl/csl_qm_queue.h */
 } PKTIO_CFG_T;
 
 
index a953fef5c9eca3475a3dddd7ad981a1baaac72aa..9ebe8cc7ee4babb2ab05a1ee3b30fdc1fd683399 100755 (executable)
@@ -60,7 +60,8 @@ static NETAPI_CFG_T netapi_default_cfg=
     TUNE_NETAPI_DEFAULT_BUFFER_SIZE,   //size of buffers in default heap
     0,
     0,
-    0
+    0,
+    NULL                                   /* Resource manager handle to use RM server */
 };
 
 HPLIB_SPINLOCK_IF_T spinlock_lol =
@@ -134,8 +135,7 @@ NETAPI_T netapi_init(int                master,
     NETAPI_HANDLE_T * p_master;
     if (!p) return NULL;
     p->master = master;
-    //p->fNssGen2 = p_netapiDeviceCfg->fNssGen2;
-    
+
     /*  SYS_MASTER: The following segment should be done 1 Time per system boot by global master process's main core/thread */
     if (master == NETAPI_SYS_MASTER)
     {
@@ -157,10 +157,9 @@ NETAPI_T netapi_init(int                master,
     }
     /*ALL others:  we are not the system master; assume SYS_MASTER has
       created SHM area for us already, so just open it */
-    else 
+    else
     {
         pBase = hplib_shmOpen(HPLIB_SHM_SIZE);
-        //error check;  
         if (!pBase)
         {
             netapi_Log("netapi_init: hplib_shmOpen error\n");
@@ -194,6 +193,7 @@ NETAPI_T netapi_init(int                master,
         pnetapiShm->netapi_netcp_cfg_lock = hplib_spinLock_UNLOCKED_INITIALIZER;
         pnetapiShm->netapi_netcp_cfg_l3_classi_lock = hplib_spinLock_UNLOCKED_INITIALIZER;
         pnetapiShm->netapi_util_lock = hplib_spinLock_UNLOCKED_INITIALIZER;
+
         if (p_cfg)
         {
             memcpy(&pnetapiShm->netapi_global.cfg,p_cfg, sizeof(NETAPI_CFG_T));
@@ -214,8 +214,8 @@ NETAPI_T netapi_init(int                master,
         pnetapiShm = (NETAPI_SHM_T*)hplib_shmGetEntry(pBase, NETAPI_ENTRY);
     }
 
-    //all:  for convenience set a back pointer to the SOC global area (in SHM)  
-    //      and process global in netapi_proc_global
+    /* all for convenience set a back pointer to the SOC global area
+       (in SHM) and process global in netapi_proc_global */
     p->global = (void *) &pnetapiShm->netapi_global;
     p->proc_global = (void *)&netapi_proc_global;
     /* Update spinLock to point to either MP spinlock or fast spinlocks, this is 
@@ -247,9 +247,8 @@ NETAPI_T netapi_init(int                master,
     /* system init */
     if(master == NETAPI_SYS_MASTER)
     {
-        err = netapip_systemInit(p,
-                                 TRUE);
-        if (err<0) 
+        err = netapip_systemInit(p, TRUE);
+        if (err < 0)
         {
             goto ERR_netapi_init;
         }
@@ -278,14 +277,14 @@ NETAPI_T netapi_init(int                master,
     else if (master == NETAPI_CORE_MASTER)
     {
         /* Start the QMSS. */
-        if (netapip_startQm() != 1)
+        if (netapip_startQm(pnetapiShm->netapi_global.cfg.rmHandle) != 1)
         {
             goto ERR_netapi_init;
         }
         netapip_startNwal(p_master->netcp_heap, 
                           p_master->netcp_control_rx_heap,
                           p_master->netcp_control_tx_heap, 
-                                       &p->nwal_local,
+                          &p->nwal_local,
                           &pnetapiShm->netapi_global.cfg,
                           &pnetapiShm->netapi_global.nwal_context);
     }
@@ -334,6 +333,7 @@ void netapi_shutdown(NETAPI_T h)
     netapi_Log("netapi: WARNING shutdown may not be fully implemented\n");
     if (p->master == NETAPI_SYS_MASTER)
     {
+    
         /* Un-configure rules for execption packet handling */
         netapi_netcpCfgExceptions(p,
                               NETCP_CFG_ALL_EXCEPTIONS,
@@ -356,6 +356,7 @@ void netapi_shutdown(NETAPI_T h)
             if (p->createdHeaps[i])  {netapi_closeHeap(h,p->createdHeaps[i]);p->createdHeaps[i]=NULL;}
         }
         netapip_cleanupAtStart();  //clear 1st 50 not-specified queues
+        //netapip_cleanupAtStart();  //clear 1st 50 not-specified queues
         //reset DDR malloc area
         hplib_resetMallocArea(0);
         hplib_vmTeardown();
index c14d42114290cdcaba94c71db85d793af40d2f66..d8d29202317f67612ffc471a66a77f2edfc6e5d1 100755 (executable)
@@ -175,10 +175,15 @@ int netapip_qmSetupMemRegion(
  * DESCRIPTION:  Internal NETAPI function to start QM
  *               once per thread/core
  ********************************************************************/
-int netapip_startQm(void)
+int netapip_startQm(void* rmClientServiceHandle)
 {
      int32_t          result;
-     result = Qmss_start();
+     Qmss_StartCfg    startCfg;
+
+     startCfg.rmServiceHandle = rmClientServiceHandle;
+     startCfg.pQmssGblCfgParams = NULL;
+     //result = Qmss_start();
+     result = Qmss_startCfg(&startCfg);
      if (result != QMSS_SOK)
      {
          netapi_Log ("netapip_startQm: Qmss_start failed with error code %d\n", result);
@@ -702,6 +707,16 @@ int netapip_systemInit(NETAPI_HANDLE_T * handle,
                           2,
                           &netapi_VM_MempoolAttr[0]);
 
+    if (result == hplib_OK)
+        netapi_Log("netapip_systemInit: - hplib_vmInit pass\n");
+    else
+    {
+        netapi_Log("netapip_systemInit: - hplib_vmInit fail\n");
+        return -1;
+    }
+
+
+
     if (global_master_process == TRUE)
     {
         hplib_initMallocArea(0);
@@ -715,17 +730,15 @@ int netapip_systemInit(NETAPI_HANDLE_T * handle,
             return -1;
     }
 
-    if (result == hplib_OK) netapi_Log("netapip_systemInit: - memory set  up OK\n");
-    else {netapi_Log("netapip_systemInit: - memory set up failed\n"); return -1;}
 
     if(global_master_process == FALSE)
     {
-        //------------------------------------------------
-        //partial initialization.  For process, not for SOC
-        //------------------------------------------------
+        /****************************************************
+         * partial initialization.  For process, not for SOC
+         ***************************************************/
        
-/* Start the QMSS. */
-       if (netapip_startQm() != 1)
+       /* Start the QMSS. */
+       if (netapip_startQm(pnetapiShm->netapi_global.cfg.rmHandle) != 1)
        {
           netapi_Log("netapip_systemInit: returned from netapip_startQm with failure\n");
           return -1;
@@ -766,8 +779,12 @@ int netapip_systemInit(NETAPI_HANDLE_T * handle,
                                &handle->nwal_local,
                                &pnetapiShm->netapi_global.cfg,
                                &pnetapiShm->netapi_global.nwal_context);
-       if (result<0) {netapi_Log("netapi start_nwal() failed\n"); return -1; }
-       netapi_Log("netapip_systemInit: returned from netapip_startNwal\n");
+        if (result<0)
+        {
+            netapi_Log("netapi start_nwal() failed\n");
+            return -1;
+        }
+        netapi_Log("netapip_systemInit: returned from netapip_startNwal\n");
     }
 
 #ifdef NETAPI_ENABLE_SECURITY
@@ -786,8 +803,6 @@ int netapip_systemInit(NETAPI_HANDLE_T * handle,
    netapi_VM_SaContextVaddr= (char *) NULL;
 #endif
 
-/*  TODO: the QM regions is application specific and needs to be moved 
-    since number of regions created is appliction specific, put this in netapip_systemInit */
     /* (3) Allocate 2 QM regions from continguous chunk above */
     netapi_VM_QMemGlobalDescRam = 
                                   (void *)hplib_vmMemAlloc((TUNE_NETAPI_NUM_GLOBAL_DESC *
@@ -807,7 +822,8 @@ int netapip_systemInit(NETAPI_HANDLE_T * handle,
 #endif
 
     /* Initialize Queue Manager Sub System */
-    result = netapip_initQm (pnetapiShm->netapi_global.cfg.def_max_descriptors);
+    result = netapip_initQm (pnetapiShm->netapi_global.cfg.def_max_descriptors,
+                             pnetapiShm->netapi_global.cfg.rmHandle);
     
     if (result != 1)
     {
@@ -816,7 +832,7 @@ int netapip_systemInit(NETAPI_HANDLE_T * handle,
     }
 
     /* Start the QMSS. */
-    if (netapip_startQm() != 1)
+    if (netapip_startQm(pnetapiShm->netapi_global.cfg.rmHandle) != 1)
     {
       netapi_Log("netapip_systemInit: returned from netapip_startQm with failure\n");
         return -1;
@@ -825,20 +841,21 @@ int netapip_systemInit(NETAPI_HANDLE_T * handle,
 
     //clean our old junk in 1st bunch of queues that will be allocated to us
     netapip_cleanupAtStart();
- netapi_Log("netapip_systemInit: returned from netapip_cleanupAtStart\n");
     /* Initialize the global descriptor memory region. */
     result= netapip_qmSetupMemRegion( 
                       pnetapiShm->netapi_global.cfg.def_tot_descriptors_for_us,
                       TUNE_NETAPI_DESC_SIZE,
                       (unsigned int *) netapi_VM_QMemGlobalDescRam,
                       TUNE_NETAPI_QM_GLOBAL_REGION);
-    if(result <0) {netapi_Log("netapip_systemInit: can't setup QM shared region\n"); return -1;}
+    if(result <0)
+    {
+        netapi_Log("netapip_systemInit: can't setup QM shared region\n");
+        return -1;
+    }
 
-netapi_Log("netapip_systemInit: returned from netapip_qmSetupMemRegion\n");
     /* Initialize CPPI CPDMA */
 
-    result = netapip_initCppi();
-    netapi_Log("netapip_systemInit: returned from netapip_initCppi\n");
+    result = netapip_initCppi(pnetapiShm->netapi_global.cfg.rmHandle);
     if (result != 1)
     {
         netapi_Log ("netapi: Error initializing CPPI SubSystem error code : %d\n",result);
@@ -851,7 +868,6 @@ netapi_Log("netapip_systemInit: returned from netapip_qmSetupMemRegion\n");
     /* create main pkt heap */
     /* Initialize the Shared Heaps. */
     Pktlib_sharedHeapInit();
-    netapi_Log("netapip_systemInit: returned from Pktlib_sharedHeapInit\n");
     /* Populate the heap interface table. */
     netapi_pktlib_ifTable.data_malloc             = netapip_sharedMemoryMalloc;
     netapi_pktlib_ifTable.data_free               = netapip_sharedMemoryFree;
@@ -873,7 +889,6 @@ netapi_Log("netapip_systemInit: returned from netapip_qmSetupMemRegion\n");
 
     /* Create Shared Heap with specified configuration. */
     sharedHeapHandle = Pktlib_createHeap(&heapCfg, &errCode);
-     netapi_Log("netapip_systemInit: returned from Pktlib_createHeap1\n");
     //todo -> cleanup on failure
     if (!sharedHeapHandle) { netapi_Log(">'netapi' heap create failed, Error Code: %d\n",errCode); return -1;}
     handle->netcp_heap= sharedHeapHandle;
@@ -886,7 +901,6 @@ netapi_Log("netapip_systemInit: returned from netapip_qmSetupMemRegion\n");
     heapCfg.numZeroBufferPackets= 0;
 
     controlRxHeapHandle = Pktlib_createHeap(&heapCfg, &errCode);
-     netapi_Log("netapip_systemInit: returned from Pktlib_createHeap2\n");
    //todo -> cleanup on failure
    if (!controlRxHeapHandle) { netapi_Log("netapi -'netapi_control_rx' heap create failed, Error Code: %d\n",errCode); return -1;}
    handle->netcp_control_rx_heap= controlRxHeapHandle;
@@ -896,7 +910,6 @@ netapi_Log("netapip_systemInit: returned from netapip_qmSetupMemRegion\n");
    heapCfg.numPkts             = TUNE_NETAPI_CONFIG_NUM_CTL_TX_BUF;
 
    controlTxHeapHandle = Pktlib_createHeap(&heapCfg, &errCode);
-    netapi_Log("netapip_systemInit: returned from Pktlib_createHeap3\n");
    //todo -> cleanup on failure
    if (!controlTxHeapHandle) { netapi_Log("netapi -'netapi_control_tx' heap create failed, Error Code: %d\n",errCode); return -1;}
    handle->netcp_control_tx_heap= controlTxHeapHandle;
index c7d58bc612e8f2a3bcf3878aaeaadb4c15a5102e..cd77ef03bc01d4e9d42e45bd17d50fed80cc383c 100755 (executable)
@@ -249,11 +249,11 @@ typedef struct NETAPI_SHM_Tag
 } NETAPI_SHM_T;
 
 //internal initialization routines */
-int netapip_initQm(int max_descriptors);
+int netapip_initQm(int max_descriptors, void* rmClientServiceHandle);
 
-int netapip_initCppi(void);
+int netapip_initCppi(void* rmClientServiceHandle);
 
-int netapip_startQm(void);
+int netapip_startQm(void* rmClientServiceHandle);
 int netapip_initNwal(int region2use,
                      Pktlib_HeapIfTable * p_table,
                      NETAPI_NWAL_GLOBAL_CONTEXT_T * p_nwal_context,
index 4a19aaba230861a6d8ee108ec879fadebf08db07..ea9c6f2fd27c89737fe22d0bc42f0fd6f5fc285c 100755 (executable)
@@ -54,7 +54,6 @@
 #include "qmss_device.c"
 #include "cppi_device.c"
 
-
 /********************************************************************
  * FUNCTION PURPOSE:  Internal NETAPI macro to convert to IP Register
  *                    Virtual Address from a mapped base Virtual
@@ -80,10 +79,13 @@ static inline void* NETAPI_GET_REG_VADDR (void *    virtBaseAddr,
  ********************************************************************
  * DESCRIPTION:  Internal NETAI function ti initialize CPPI
  ********************************************************************/
-int netapip_initCppi(void)
+int netapip_initCppi(void* rmClientServiceHandle)
 {
     int32_t result, i;
     Cppi_GlobalConfigParams     netapi_cppiGblCfgParams[CPPI_MAX_CPDMA];
+    Cppi_StartCfg               netapi_cppiStartCfg;
+
+    memset(&netapi_cppiStartCfg, 0, sizeof(Cppi_StartCfg));
 
     for (i=0; i<CPPI_MAX_CPDMA; i++)
         netapi_cppiGblCfgParams[i] = cppiGblCfgParams[i];
@@ -171,6 +173,11 @@ int netapip_initCppi(void)
     {
       netapi_Log (">function cppi_init: Cppi_init failed with error code %d\n", result);
       return (-1);
+    }
+    if (rmClientServiceHandle)
+    {
+      netapi_cppiStartCfg.rmServiceHandle = rmClientServiceHandle;
+      Cppi_startCfg(&netapi_cppiStartCfg);
     }
      return 1;
 }
@@ -180,7 +187,7 @@ int netapip_initCppi(void)
  ********************************************************************
  * DESCRIPTION:  Internal NETAI function ti initialize QM (once per SOC)
  ********************************************************************/
-int netapip_initQm(int max_descriptors)
+int netapip_initQm(int max_descriptors, void* rmClientServiceHandle))
 {
     Qmss_InitCfg     qmssInitConfig;
     int32_t          result;
@@ -285,6 +292,9 @@ int netapip_initQm(int max_descriptors)
                                                       (void *)((uint32_t)netapi_VM_VirtAddr->qmssDataVaddr);
 
 
+    if (rmClientServiceHandle)
+        netapi_qmssGblCfgParams.qmRmServiceHandle = rmClientServiceHandle;
+
     netapi_qmssGblCfgParams.qmQueMgmtProxyDataReg = NULL;
     result = Qmss_init (&qmssInitConfig, &netapi_qmssGblCfgParams);
     if (result != QMSS_SOK)  {
index 39e156058801061b7c2d2e59dee86a37118d5c7b..16ed1b758b4d588e947bb8e364b7c0e1ccd765d3 100755 (executable)
@@ -79,12 +79,14 @@ static inline void* NETAPI_GET_REG_VADDR (void *    virtBaseAddr,
  *****************************************************************************
  * DESCRIPTION: The function will initialize the CPPI
  *****************************************************************************/
-int netapip_initCppi(void)
+int netapip_initCppi(void* rmClientServiceHandle)
 {
 
     int32_t                         result;
     Cppi_GlobalConfigParams         netapi_cppiGblCfgParams;
+    Cppi_StartCfg               netapi_cppiStartCfg;
 
+    memset(&netapi_cppiStartCfg, 0, sizeof(Cppi_StartCfg));
     netapi_cppiGblCfgParams = cppiGblCfgParams;
 
     /* PASS CPDMA regs */
@@ -138,11 +140,19 @@ int netapip_initCppi(void)
         NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
         CSL_QMSS_CFG_BASE,
         (uint32_t)netapi_cppiGblCfgParams.cpDmaCfgs[Cppi_CpDma_QMSS_CPDMA].rxFlowRegs);
+
     result = Cppi_init (&netapi_cppiGblCfgParams);
     if (result != CPPI_SOK)  {
         netapi_Log ("function testNwGlobCppiInit: Cppi_init failed with error code %d\n", result);
         return (-1);
     }
+
+    if (rmClientServiceHandle)
+    {
+      netapi_cppiStartCfg.rmServiceHandle = rmClientServiceHandle;
+      Cppi_startCfg(&netapi_cppiStartCfg);
+    }
+
     return (1);
 }
 
@@ -151,7 +161,7 @@ int netapip_initCppi(void)
  *****************************************************************************
  * DESCRIPTION: The function will initialize the Queue Manager
  *****************************************************************************/
-int netapip_initQm(int max_descriptors)
+int netapip_initQm(int max_descriptors, void* rmClientServiceHandle)
 {
     Qmss_InitCfg              qmssInitConfig;
     int32_t                   result;
@@ -246,6 +256,9 @@ int netapip_initQm(int max_descriptors)
         CSL_QMSS_CFG_BASE,
        (uint32_t)netapi_qmssGblCfgParams.regs.qmBaseAddr);
 
+    if (rmClientServiceHandle)
+        netapi_qmssGblCfgParams.qmRmServiceHandle = rmClientServiceHandle;
+
     result = Qmss_init (&qmssInitConfig, &netapi_qmssGblCfgParams);
     if (result != QMSS_SOK)
     {
index bcb93f19b583baabd46b5cbba3524b14ae02a0c5..b4b7990767a9ef95ff48c7cadc8fbfc01b3b3774 100755 (executable)
@@ -873,8 +873,13 @@ PKTIO_HANDLE_T * netapi_pktioCreate(NETAPI_T n,
     uint8_t         isAllocated;
 
     *err=0;
-    int q= QMSS_PARAM_NOT_SPECIFIED;
-    int qtype=Qmss_QueueType_GENERAL_PURPOSE_QUEUE;
+    int q = QMSS_PARAM_NOT_SPECIFIED;
+
+    int qtype = Qmss_QueueType_GENERAL_PURPOSE_QUEUE;
+
+    /* over-ride only for Qmss_QueueType_GIC400_QUEUE */
+    if (p_cfg->queueType == Qmss_QueueType_GIC400_QUEUE)
+        qtype = p_cfg->queueType;
 
     if ((!p_cfg)||(!name)) {*err=NETAPI_ERR_BAD_INPUT; return NULL;}
     if ((p_cfg->flags2 & PKTIO_PKT) &&(p_cfg->flags1& PKTIO_TX)) { *err=NETAPI_ERR_BAD_INPUT; return NULL;};
@@ -907,14 +912,16 @@ PKTIO_HANDLE_T * netapi_pktioCreate(NETAPI_T n,
      p->q  = Qmss_queueOpen(qtype,
                                 q, 
                                 &isAllocated);
-    if (p->q == (Qmss_QueueHnd) NULL)
+    if (p->q < 0)
     {
         netapi_Log("netapi_pktioCreate:  queueOpen failed\n");
         p->inuse=0;
         *err= NETAPI_ERR_QLLD;  ///queue lld error
         return NULL;
     }
+
     p->qInfo = Qmss_getQueueNumber(p->q);
+
     if (p_cfg->flags2 & PKTIO_PKT)
     {
         p->use_nwal = PKTIO_4_ADJ_NWAL;
index 87907d8acca8a4886f4e880487439d8ecba60906..94c95439959a15f41492295fbab70c7ec520da6a 100755 (executable)
@@ -12,6 +12,7 @@ export ARMV7LIBDIRLOCAL ?= ../../lib
 SA_INSTALL_PATH ?= $(PDK_INSTALL_PATH)/ti/drv/sa
 QMSS_INC_DIR ?= $(PDK_INSTALL_PATH)/ti/drv/qmss
 CPPI_INC_DIR ?= $(PDK_INSTALL_PATH)/ti/drv/cppi
+RM_INC_DIR ?= $(PDK_INSTALL_PATH)/ti/drv/rm
 HPLIB_INC_DIR ?= $(TRANS_SDK_INSTALL_PATH)
 NETAPI_SRC_DIR ?= $(TRANS_SDK_INSTALL_PATH)/ti/runtime/netapi
 NETAPI_INC_DIR ?=  $(TRANS_SDK_INSTALL_PATH)
@@ -24,8 +25,10 @@ ifeq ($(CPU),  cortex-a8)
         CFLAGS += -DCORTEX_A8
 endif
 
+NT_RM_OBJS = $(ARMV7OBJDIR)/netapi/utils/sockutils.o  $(ARMV7OBJDIR)/netapi/utils/netapi_util_rm.o
+
 TRIE_OBJS=$(ARMV7OBJDIR)/netapi/test/trie.o
-NT_OBJS= $(ARMV7OBJDIR)/netapi/test/net_test_loopback.o  $(ARMV7OBJDIR)/netapi/test/stubs.o $(ARMV7OBJDIR)/netapi/test/net_test_utils.o $(ARMV7OBJDIR)/netapi/test/net_test_sa_utils.o $(ARMV7OBJDIR)/netapi/test/net_test_thread_utils.o
+NT_OBJS= $(ARMV7OBJDIR)/netapi/test/net_test_loopback.o $(ARMV7OBJDIR)/netapi/test/stubs.o $(ARMV7OBJDIR)/netapi/test/net_test_utils.o $(ARMV7OBJDIR)/netapi/test/net_test_sa_utils.o $(ARMV7OBJDIR)/netapi/test/net_test_thread_utils.o
 #
 NT_ROUTER_OBJS= $(ARMV7OBJDIR)/netapi/test/net_test_router.o  $(ARMV7OBJDIR)/netapi/test/stubs.o $(ARMV7OBJDIR)/netapi/test/net_test_utils.o $(ARMV7OBJDIR)/netapi/test/net_test_sa_utils.o $(ARMV7OBJDIR)/netapi/test/net_test_thread_utils.o
 #
@@ -46,6 +49,7 @@ HP_LIB = -lhplib_$(DEVICE)
 NETAPI_LIB = -lnetapi_$(DEVICE)
 NWAL_LIB = -lnwalsa_$(DEVICE)
 SA_LIB = -lsa
+RM_LIB = -lrm
 #
 #with security enabled..
 
@@ -73,10 +77,10 @@ HP_LIB ?= -lhplib_k2l
 ifeq ($(USEDYNAMIC_LIB), yes)
 #presuming ARM executable would depend on dynamic library dependency
 EXE_EXTN = _so
-LIBS     = $(QMSS_LIB) $(CPPI_LIB) $(PA_LIB) $(PKTLIB_LIB) $(NETAPI_LIB) $(HP_LIB) $(SA_LIB) $(NWAL_LIB)
+LIBS     = $(QMSS_LIB) $(CPPI_LIB) $(PA_LIB) $(PKTLIB_LIB) $(NETAPI_LIB) $(HP_LIB) $(SA_LIB) $(NWAL_LIB) $(RM_LIB)
 else
 #forcing ARM executable to depend on static LLD libraries
-LIBS = -static $(QMSS_LIB) $(CPPI_LIB) $(PA_LIB) $(PKTLIB_LIB) $(NETAPI_LIB) $(HP_LIB) $(SA_LIB) $(NWAL_LIB) -Wl,-Bdynamic
+LIBS = -static $(QMSS_LIB) $(CPPI_LIB) $(PA_LIB) $(PKTLIB_LIB) $(NETAPI_LIB) $(HP_LIB) $(SA_LIB) $(NWAL_LIB) $(RM_LIB) -Wl,-Bdynamic
 EXE_EXTN =
 endif
 
@@ -89,7 +93,7 @@ ifdef CROSS_TOOL_INSTALL_PATH
  LD = $(CROSS_TOOL_INSTALL_PATH)/$(CROSS_TOOL_PRFX)gcc
 endif
 
-CFLAGS+= $(DEBUG_FLAG) -I../ -I. -I$(NETAPI_SRC_DIR) -I$(NETAPI_SRC_DIR)/src -I$(HPLIB_INC_DIR) -I$(NETAPI_INC_DIR)-I$(PDK_INSTALL_PATH) -I$(NWAL_INSTALL_PATH) -I$(PKTLIB_INSTALL_PATH) -I$(SA_INSTALL_PATH) -I$(QMSS_INC_DIR) -I$(CPPI_INC_DIR) $(CSL_DEVICE) -D__ARMv7 -D_VIRTUAL_ADDR_SUPPORT -D__LINUX_USER_SPACE -D_LITTLE_ENDIAN=1 -DNWAL_ENABLE_SA -DMAKEFILE_BUILD -D _GNU_SOURCE
+CFLAGS+= $(DEBUG_FLAG) -I../ -I. -I$(NETAPI_SRC_DIR) -I$(NETAPI_SRC_DIR)/src -I$(NETAPI_SRC_DIR)/util -I$(HPLIB_INC_DIR) -I$(NETAPI_INC_DIR)-I$(PDK_INSTALL_PATH) -I$(NWAL_INSTALL_PATH) -I$(PKTLIB_INSTALL_PATH) -I$(SA_INSTALL_PATH) -I$(QMSS_INC_DIR) -I$(CPPI_INC_DIR) -I$(RM_INC_DIR) $(CSL_DEVICE) -D__ARMv7 -D_VIRTUAL_ADDR_SUPPORT -D__LINUX_USER_SPACE -D_LITTLE_ENDIAN=1 -DNWAL_ENABLE_SA -DMAKEFILE_BUILD -D _GNU_SOURCE
 # Linker options
 INTERNALLINKDEFS = -Wl,--start-group $(LIBS) -Wl,--end-group -lrt -pthread  -L$(ARMV7LIBDIR)  -L$(ARMV7LIBDIRLOCAL) -L$(ARMV7SALIBDIR)
 
@@ -102,6 +106,10 @@ clean:
        rm -f $(ARMV7OBJDIR)/netapi/test/*.o
        rm -f $(ARMV7BINDIR)/netapi/test/*
 
+$(ARMV7OBJDIR)/netapi/utils/%.o: $(NETAPI_SRC_DIR)/utils/%.c $(ARMV7OBJDIR)/netapi/utils/.created
+       @echo compiling $<
+       $(CC) -c  $(CFLAGS)  $<  -o $@
+
 $(ARMV7OBJDIR)/netapi/test/%.o: $(NETAPI_SRC_DIR)/test/%.c $(ARMV7OBJDIR)/netapi/test/.created
        @echo compiling $<
        $(CC) -c  $(CFLAGS)  $<  -o $@
@@ -112,8 +120,11 @@ $(ARMV7OBJDIR)/netapi/test/.created:
 $(ARMV7BINDIR)/netapi/test/.created:
        @mkdir -p $(ARMV7BINDIR)/netapi/test/
 
-$(ARMV7BINDIR)/netapi/test/net_test_loopback_$(DEVICE):  $(NT_OBJS) $(TRIE_OBJS)
-       $(CC) $(LDFLAGS)  $(NT_OBJS) $(TRIE_OBJS) $(INTERNALLINKDEFS)  -o $(ARMV7BINDIR)/netapi/test/net_test_loopback_$(DEVICE)$(EXE_EXTN)
+$(ARMV7OBJDIR)/netapi/utils/.created:
+       @mkdir -p $(ARMV7OBJDIR)/netapi/utils/
+
+$(ARMV7BINDIR)/netapi/test/net_test_loopback_$(DEVICE): $(NT_OBJS) $(TRIE_OBJS) $(NT_RM_OBJS)
+       $(CC) $(LDFLAGS)  $(NT_OBJS) $(TRIE_OBJS) $(NT_RM_OBJS) $(INTERNALLINKDEFS)  -o $(ARMV7BINDIR)/netapi/test/net_test_loopback_$(DEVICE)$(EXE_EXTN)
 
 $(ARMV7BINDIR)/netapi/test/net_test_max_params:  $(NT_MAX_PARAMS_OBJS) $(TRIE_OBJS)
        $(CC) $(LDFLAGS)  $(NT_MAX_PARAMS_OBJS) $(TRIE_OBJS) $(INTERNALLINKDEFS)  -o $(ARMV7BINDIR)/netapi/test/net_test_max_params$(EXE_EXTN)
index 736ba8baa1d86f4f02ce9fe1a80e0a84539b0815..b5fbb071296d725b907a899a60d66aa4072009db 100755 (executable)
@@ -133,7 +133,8 @@ TUNE_NETAPI_DEFAULT_NUM_BUFFERS,   //#descriptors+buffers in default heap
 TUNE_NETAPI_DEFAULT_BUFFER_SIZE+128+128,  //size of buffers in default heap
 128   ,  //tail room
 256,      //extra room 
-0
+0,
+NULL
 };
 
 Pktlib_HeapHandle OurHeap;     //default heap, used by producer
index 8516f7e1ce3b5ee8894e81be825fe8c8a9c64539..ff5e96911fff056b53d235b62a2d47b0ffd7477c 100755 (executable)
@@ -162,7 +162,8 @@ TUNE_NETAPI_DEFAULT_NUM_BUFFERS,   //#descriptors+buffers in default heap
 TUNE_NETAPI_DEFAULT_BUFFER_SIZE+128+128,  //size of buffers in default heap
 128,       //tail room
 256,      //extra room
-0
+0,
+NULL
 };
 
 Pktlib_HeapHandle OurHeap;     //default heap, used by producer
index cb70c1216c01183e3c929f711d74e53522481fe7..3e47c94ba442701eba7d7627ec763ee74e042ec2 100755 (executable)
@@ -69,6 +69,8 @@ extern int QUIT;
 extern netTestStats_T stats[TUNE_NETAPI_NUM_CORES];
 extern paSysStats_t netcp_stats;
 
+extern Rm_ServiceHandle   *rmClientServiceHandle;
+
 
 netTestConfig_t netTestCfg;
 static netTestConfigFile_t config_file;
@@ -117,7 +119,8 @@ static NETAPI_CFG_T our_netapi_default_cfg=
     TUNE_NETAPI_DEFAULT_BUFFER_SIZE+128+128,  //size of buffers in default heap
     128, //tail room
     256, //extra room
-    0
+    0,
+    NULL
 };
 
 NETAPI_T netapi_handle;
@@ -996,13 +999,11 @@ void slow_path_thread(uint32_t index)
 #else
     for (i = netTestCfg.sp_proc_start[index]; i <= netTestCfg.sp_proc_end[index];i++)
     {
-        printf("slow_path_thread: setting cpu %d to cpu_set\n", i);
         CPU_SET( i, &cpu_set);
     }
     hplib_utilSetupThread(thread_num, &cpu_set, hplib_spinLock_Type_LOL);
 #endif
-    worker_nh[thread_num] = netapi_init(NETAPI_CORE_MASTER,
-                                        NULL);
+    worker_nh[thread_num] = netapi_init(NETAPI_CORE_MASTER,NULL);
 
     if (worker_nh[thread_num] == NULL)
     {
@@ -1025,6 +1026,7 @@ void slow_path_thread(uint32_t index)
     netapi_schedRun(scheduler[thread_num], &err);
 
 ERR_slow_path_thread:
+    printf("slow_path_thread: calling netapi_shutdown\n");
     netapi_shutdown(worker_nh[thread_num]);
 }
 
@@ -1057,8 +1059,8 @@ void fast_path_thread(uint32_t index)
     }
     hplib_utilSetupThread(thread_num, &cpu_set, hplib_spinLock_Type_LOL);
 #endif
-    worker_nh[thread_num]=netapi_init(NETAPI_CORE_MASTER,
-                                      NULL);
+    worker_nh[thread_num]=netapi_init(NETAPI_CORE_MASTER,NULL);
+    
     if (worker_nh[thread_num] == NULL)
     {
         printf("fast_path_thread: netapi_init failure, exiting\n");
@@ -1093,7 +1095,8 @@ void fast_path_thread(uint32_t index)
 ERR_fast_path_thread:
     netapi_pktioClose(rx_chan, &err);
     netapi_pktioClose(sb_rx_chan, &err);
-
+    
+    printf("fast_path_thread: calling netapi_shutdown\n");
     netapi_shutdown(worker_nh[thread_num]);
 }
 
@@ -1129,35 +1132,39 @@ int main(int argc, char **argv)
         printf("Cant open config file: filepath %s, %s\n", input_file_name, strerror(errno));
         exit(1);
     }
-    else
+
+    if (initRm())
     {
-        memset(&config_file, 0, sizeof(netTestConfigFile_t));
-        memset(&netTestCfg, 0, sizeof(netTestConfig_t));
-        
-        netTest_utilProcessConfigFile(fpr,&config_file);
+        printf("main: initRm() returned error\n");
+        exit(1);
+    }
+    our_netapi_default_cfg.rmHandle = rmClientServiceHandle;
+    memset(&config_file, 0, sizeof(netTestConfigFile_t));
+    memset(&netTestCfg, 0, sizeof(netTestConfig_t));
 
-        netTest_utilParseMac(&config_file);
+    netTest_utilProcessConfigFile(fpr,&config_file);
 
-        /* parse slow path/fast path thread configuration parameters */
-        netTest_utilParseThreadParams(&config_file);
+    netTest_utilParseMac(&config_file);
 
-        netTest_utilParseIP(&config_file);
+    /* parse slow path/fast path thread configuration parameters */
+    netTest_utilParseThreadParams(&config_file);
 
-        netTest_utilParseIpsecMode(&config_file);
+    netTest_utilParseIP(&config_file);
 
-        /* DSP mac processing */
-        parse_dsp_mac(&config_file.dsp_mac[0]);
+    netTest_utilParseIpsecMode(&config_file);
 
-       /* DSP IP processing */
-        parse_dsp_ip(&config_file.dsp_ip[0]);
+    /* DSP mac processing */
+    parse_dsp_mac(&config_file.dsp_mac[0]);
 
-        /* IPSEC interface number processing */
-        parse_simple_param_u32((char*)&config_file.ipsec_if_no[0], &netTestCfg.ipsec_if_no);
+    /* DSP IP processing */
+    parse_dsp_ip(&config_file.dsp_ip[0]);
 
-        netTest_utilParseSA(&config_file);
+    /* IPSEC interface number processing */
+    parse_simple_param_u32((char*)&config_file.ipsec_if_no[0], &netTestCfg.ipsec_if_no);
 
-        parse_simple_param_u32(&config_file.dest_udp_port_config, &netTestCfg.dest_udp_port_config);
-    }
+    netTest_utilParseSA(&config_file);
+
+    parse_simple_param_u32(&config_file.dest_udp_port_config, &netTestCfg.dest_udp_port_config);
 
     memset(&sa_info, 0, sizeof(sa_info));
 
@@ -1170,17 +1177,17 @@ int main(int argc, char **argv)
 #endif
 
     /* create netapi */
+
     netapi_handle = netapi_init(NETAPI_SYS_MASTER,
                                 &our_netapi_default_cfg);
 
     if (netapi_handle == NULL)
     {
         printf("main: netapi_init failure, exiting\n");
+        closeRm();
         exit(1);
     }
 
-
-
     /* configure expection packet handling with netapi */
     netapi_netcpCfgExceptions(netapi_handle,
                               NETCP_CFG_ALL_EXCEPTIONS,
@@ -1196,6 +1203,7 @@ int main(int argc, char **argv)
     if (!ourHeap)
     {
         printf("Pktlib_findHeapByName()  fail\n");
+        closeRm();
         exit(1);
     }
 
@@ -1203,7 +1211,12 @@ int main(int argc, char **argv)
 
     /* create scheduler instance */
     our_sched =netapi_schedOpen(netapi_handle,&our_sched_cfg, &err);
-    if (!our_sched) {printf("sched create failed\n"); exit(1);}
+    if (!our_sched)
+    {
+        printf("sched create failed\n");
+        closeRm();
+        exit(1);
+    }
 
 
     /*create net_test MAC interfaces, attach IP to created MAC interfaces */
@@ -1215,6 +1228,7 @@ int main(int argc, char **argv)
     if (!p_trie_sa_rx || !p_trie_sa_tx)
     {
         printf("trie alloc for SA  failed\n");
+        closeRm();
         exit(1);
     }
 
@@ -1238,24 +1252,25 @@ int main(int argc, char **argv)
     printf("\n Enter 's' for stats or 'q'to quit net_test_loopback app, or 'h' for help\n");
 
 
+
+
     char c;
-        //this thread of execution (main) now just waits on user input
-        for(;;)
-        {
-           printf(">");
-           c=getchar();
-           if (c=='q')
-            {
-                QUIT=1;
-                printf("net_test_loopback: please wait for application shutdown and resource cleanup\n");
-                break;
-           }
-           else if (c=='s') netTest_utilsStatsCb(netapi_handle, &netcp_stats);
-           else if (c=='h') printf("'q' to quit,  's' for stats, 'h' for help\n");
-        }
+    //this thread of execution (main) now just waits on user input
+    for(;;)
+    {
+       printf(">");
+       c=getchar();
+       if (c=='q')
+       {
+            QUIT=1;
+            printf("net_test_loopback: please wait for application shutdown and resource cleanup\n");
+            break;
+       }
+       else if (c=='s') netTest_utilsStatsCb(netapi_handle, &netcp_stats);
+       else if (c=='h') printf("'q' to quit,  's' for stats, 'h' for help\n");
+    }
 
         netTest_utilRemoveSpFpThreads(netTestCfg.num_sp_threads, netTestCfg.num_fp_threads);
-
 }
 #else
     /*********************************************/
@@ -1281,6 +1296,7 @@ int main(int argc, char **argv)
 #endif
 
     netapi_shutdown(netapi_handle);
+    closeRm();
     printf("net_test shutdown complete\n");
 
 }
index 75b0460914ac3ddca8560319bed336515b9db6b1..4c2a0c3290c67d81c92d58dfc4b7865775d9e1b2 100755 (executable)
@@ -104,7 +104,8 @@ TUNE_NETAPI_DEFAULT_NUM_BUFFERS,   //#descriptors+buffers in default heap
 TUNE_NETAPI_DEFAULT_BUFFER_SIZE+128+128,  //size of buffers in default heap
 128,       //tail room
 256,      //extra room
-0
+0,
+NULL
 };
 
 NETAPI_T netapi_handle;
index 2370339834841e484f6f21a1670d72b28550ad0e..4e03d484cb44aaed41df896532252ec286af1b23 100755 (executable)
@@ -131,7 +131,8 @@ TUNE_NETAPI_DEFAULT_NUM_BUFFERS,   //#descriptors+buffers in default heap
 TUNE_NETAPI_DEFAULT_BUFFER_SIZE+128+128,  //size of buffers in default heap
 128,  //tail room
 256,  //extra room
-0
+0,
+NULL
 };
 
 
diff --git a/ti/runtime/netapi/utils/netapi_util_rm.c b/ti/runtime/netapi/utils/netapi_util_rm.c
new file mode 100755 (executable)
index 0000000..d1bf3fc
--- /dev/null
@@ -0,0 +1,357 @@
+/**************************************************************
+ * FILE PURPOSE :  NETAPI Resource Manager Configuration 
+ *          
+ **************************************************************
+ * @file netapi_rm.c
+ * 
+ * @brief DESCRIPTION:  netapi resource manager file used for user space
+ *                      transport library
+ * 
+ * REVISION HISTORY:
+ *
+ *  Copyright (c) Texas Instruments Incorporated 2014
+ * 
+ *  Redistribution and use in source and binary forms, with or without 
+ *  modification, are permitted provided that the following conditions 
+ *  are met:
+ *
+ *    Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ *    Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the 
+ *    documentation and/or other materials provided with the   
+ *    distribution.
+ *
+ *    Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*****************************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+#include "ti/runtime/netapi/netapi.h"
+
+
+uint32_t    Osal_rm_MallocCounter = 0;
+uint32_t    Osal_rm_FreeCounter   = 0;
+
+
+/* Socket Includes */
+#include "sockutils.h"
+#include "sockrmmsg.h"
+
+/* RM Includes */
+#include <ti/drv/rm/rm.h>
+#include <ti/drv/rm/rm_transport.h>
+#include <ti/drv/rm/rm_services.h>
+
+/* Socket timeout */
+#define CLIENT_SOCK_TIMEOUT_USEC     (500)
+
+/* Application's registered RM transport indices */
+#define SERVER_TO_CLIENT_MAP_ENTRY   0
+/* Maximum number of registered RM transports */
+#define MAX_MAPPING_ENTRIES          1
+
+/* Error checking macro */
+#define RM_ERROR_CHECK(checkVal, resultVal, rmInstName, printMsg)                 \
+    if (resultVal != checkVal) {                                                  \
+        char errorMsgToPrint[] = printMsg;                                        \
+        printf("RM Inst : %s : ", rmInstName);                                    \
+        printf("%s with error code : %d, exiting\n", errorMsgToPrint, resultVal); \
+        return(-1);                                                               \
+    }
+
+/* RM registered transport mapping structure */
+typedef struct trans_map_entry_s {
+    /* Registered RM transport handle */
+    Rm_TransportHandle        transportHandle;
+    /* Remote socket tied to the transport handle */
+    sock_name_t              *remote_sock;
+} Transport_MapEntry;
+
+
+
+
+
+/* RM Client Vars */
+Rm_Handle           rmClientHandle = NULL;
+Rm_ServiceHandle   *rmClientServiceHandle = NULL;
+sock_h              rmClientSocket;
+
+/* Client instance name (must match with RM Global Resource List (GRL) and policies */
+char                rmClientName[RM_NAME_MAX_CHARS] = "RM_Client0";
+
+/* Client socket name */
+char                rmClientSockName[] = "/tmp/var/run/rm/rm_client";
+
+/* Transport map stores the RM transport handle to IPC MessageQ queue mapping */
+Transport_MapEntry  rmTransportMap[MAX_MAPPING_ENTRIES];
+
+
+hplib_spinLock_T net_test_rm_lock;
+
+
+
+void *Osal_rmMalloc (uint32_t num_bytes)
+{
+    /* Increment the allocation counter. */
+    Osal_rm_MallocCounter++;
+
+    /* Allocate memory. */
+    return calloc(1, num_bytes);
+}
+void Osal_rmFree (void *ptr, uint32_t size)
+{
+    /* Increment the free counter. */
+    Osal_rm_FreeCounter++;
+    free(ptr);
+}
+
+void *Osal_rmCsEnter(void)
+{
+    return NULL;
+}
+
+void Osal_rmCsExit(void *CsHandle)
+{
+
+}
+void Osal_rmBeginMemAccess(void *ptr, uint32_t size)
+{
+    return;
+}
+void Osal_rmEndMemAccess(void *ptr, uint32_t size)
+{
+    return;
+}
+
+void *Osal_rmTaskBlockCreate(void)
+{
+    return(NULL);
+}
+
+void Osal_rmTaskBlock(void *handle)
+{
+
+}
+
+void Osal_rmTaskUnblock(void *handle)
+{
+
+}
+
+void Osal_rmTaskBlockDelete(void *handle)
+{
+
+}
+
+void Osal_rmLog (char *fmt, ... )
+{
+    va_list ap;
+    
+    va_start(ap, fmt);
+    vprintf(fmt, ap);
+    va_end(ap);
+}
+
+Rm_Packet *transportAlloc(Rm_AppTransportHandle appTransport, uint32_t pktSize, Rm_PacketHandle *pktHandle)
+{
+    Rm_Packet *rm_pkt = NULL;
+
+    rm_pkt = calloc(1, sizeof(*rm_pkt));
+    if (!rm_pkt) {
+        printf("can't malloc for RM send message (err: %s)\n", strerror(errno));
+        return (NULL);
+    }
+    rm_pkt->pktLenBytes = pktSize;
+    *pktHandle = rm_pkt;
+
+    return(rm_pkt);
+}
+
+void transportFree (Rm_Packet *rm_pkt)
+{
+    if (rm_pkt) {
+        free (rm_pkt);
+    }         
+}
+
+void transportReceive (void)
+{
+    int32_t             rm_result;
+    int                 retval;
+    int                 length = 0;
+    sock_name_t         server_sock_addr;
+    Rm_Packet          *rm_pkt = NULL;
+    struct sockaddr_un  server_addr;    
+    
+    retval = sock_wait(rmClientSocket, &length, NULL, -1);
+    if (retval == -2) {
+        /* Timeout */
+        printf("Error socket timeout\n");
+        return;
+    }
+    else if (retval < 0) {
+        printf("Error in reading from socket, error %d\n", retval);
+        return;
+    }
+    
+    if (length < sizeof(*rm_pkt)) {
+        printf("invalid RM message length %d\n", length);
+        return;
+    }
+    rm_pkt = calloc(1, length);
+    if (!rm_pkt) {
+        printf("can't malloc for recv'd RM message (err: %s)\n",
+               strerror(errno));
+        return;
+    }
+    
+    server_sock_addr.type = sock_addr_e;
+    server_sock_addr.s.addr = &server_addr;
+    retval = sock_recv(rmClientSocket, (char *)rm_pkt, length, &server_sock_addr);
+    if (retval != length) {
+        printf("recv RM pkt failed from socket, received = %d, expected = %d\n",
+               retval, length);
+        return;
+    }
+    
+
+    /* Provide packet to RM Client for processing */       
+    if ((rm_result = Rm_receivePacket(rmTransportMap[SERVER_TO_CLIENT_MAP_ENTRY].transportHandle, rm_pkt))) {
+        printf("RM failed to process received packet: %d\n", rm_result);
+    }
+
+    transportFree(rm_pkt);
+}
+
+int32_t transportSendRcv (Rm_AppTransportHandle appTransport, Rm_PacketHandle pktHandle)
+{
+    sock_name_t *server_sock_name = (sock_name_t *)appTransport;
+    Rm_Packet   *rm_pkt = (Rm_Packet *)pktHandle;
+
+    hplib_mSpinLockLock(&net_test_rm_lock);
+    if (sock_send(rmClientSocket, (char *)rm_pkt, (int) rm_pkt->pktLenBytes, server_sock_name)) {
+        printf("send data failed\n");
+    }
+
+    /* Wait for response from Server */
+    transportReceive();
+    hplib_mSpinLockUnlock(&net_test_rm_lock);
+    return (0);
+}
+
+int connection_setup(void)
+{
+    Rm_TransportCfg rmTransCfg;
+    int32_t         rm_result;
+    int             i;
+    sock_name_t     sock_name;
+    char            server_sock_name[] = RM_SERVER_SOCKET_NAME;
+    
+    /* Initialize the transport map */
+    for (i = 0; i < MAX_MAPPING_ENTRIES; i++) {
+        rmTransportMap[i].transportHandle = NULL;
+    }
+
+    sock_name.type = sock_name_e;
+    sock_name.s.name = rmClientSockName;
+
+    rmClientSocket = sock_open(&sock_name);
+    if (!rmClientSocket) {
+        printf("connection_setup: Client socket open failed\n");
+        return (-1);
+    }
+
+    rmTransportMap[SERVER_TO_CLIENT_MAP_ENTRY].remote_sock = calloc(1, sizeof(sock_name_t));
+    rmTransportMap[SERVER_TO_CLIENT_MAP_ENTRY].remote_sock->type = sock_name_e;    
+    rmTransportMap[SERVER_TO_CLIENT_MAP_ENTRY].remote_sock->s.name = calloc(1, strlen(server_sock_name)+1);
+    strncpy(rmTransportMap[SERVER_TO_CLIENT_MAP_ENTRY].remote_sock->s.name, server_sock_name, strlen(server_sock_name)+1);
+
+    /* Register the Server with the Client instance */
+    rmTransCfg.rmHandle = rmClientHandle;
+    rmTransCfg.appTransportHandle = (Rm_AppTransportHandle) rmTransportMap[SERVER_TO_CLIENT_MAP_ENTRY].remote_sock;
+    rmTransCfg.remoteInstType = Rm_instType_SERVER;
+    rmTransCfg.transportCallouts.rmAllocPkt = transportAlloc;
+    rmTransCfg.transportCallouts.rmSendPkt = transportSendRcv;
+    rmTransportMap[SERVER_TO_CLIENT_MAP_ENTRY].transportHandle = Rm_transportRegister(&rmTransCfg, &rm_result);  
+    printf("connection_setup: complete !!!!!!!!!!!!!!!!!!!!!!!!!!\n");
+    return(0);
+}
+
+/** ============================================================================
+ *   @n@b initRm
+ *
+ *   @b Description
+ *   @n This API initializes the RM Client for the QMSS test establishing
+ *      a socket connection with the RM Server
+ * 
+ *   @return    int32_t
+ *              -1      -   Error
+ *              0       -   Success
+ * =============================================================================
+ */
+int initRm (void)
+{
+    Rm_InitCfg         rmInitCfg;
+    int32_t            result;
+
+
+    //net_test_rm_lock = hplib_spinLock_UNLOCKED_INITIALIZER;
+    hplib_mSpinLockInit(&net_test_rm_lock );
+    
+    /* Initialize the RM Client - RM must be initialized before anything else in the system */
+    memset(&rmInitCfg, 0, sizeof(rmInitCfg));
+    rmInitCfg.instName = rmClientName;
+    rmInitCfg.instType = Rm_instType_CLIENT;
+    rmClientHandle = Rm_init(&rmInitCfg, &result);
+    RM_ERROR_CHECK(RM_OK, result, rmClientName, "Initialization failed");
+
+    printf("\n\nInitialized %s\n\n", rmClientName);
+
+    /* Open Client service handle */
+    rmClientServiceHandle = Rm_serviceOpenHandle(rmClientHandle, &result);
+    RM_ERROR_CHECK(RM_OK, result, rmClientName, "Service handle open failed");
+
+    return(connection_setup());
+}
+
+int closeRm(void)
+{
+    int32_t            result;
+
+    if(rmClientHandle)
+    {
+        result = Rm_serviceCloseHandle(rmClientServiceHandle);
+        RM_ERROR_CHECK(RM_OK, result, rmClientName, "Service handle close failed");
+        
+        result = Rm_transportUnregister(rmTransportMap[SERVER_TO_CLIENT_MAP_ENTRY].transportHandle);
+        RM_ERROR_CHECK(RM_OK, result, rmClientName, "Unregister of CD transport failed");
+    
+        result = Rm_delete(rmClientHandle, 1);  
+        RM_ERROR_CHECK(RM_OK, result, rmClientName, "Instance delete failed");
+    }
+}
+
+
+
diff --git a/ti/runtime/netapi/utils/sockrmmsg.h b/ti/runtime/netapi/utils/sockrmmsg.h
new file mode 100755 (executable)
index 0000000..d3dbbec
--- /dev/null
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2013 Texas Instruments Incorporated - http://www.ti.com/
+ *
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *    Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ *    Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the
+ *    distribution.
+ *
+ *    Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef __SOCKRMMSG_H__
+#define __SOCKRMMSG_H__
+
+#include <stdint.h>
+
+#define RM_SERVER_SOCKET_NAME "/tmp/var/run/rm/rm_server"
+
+#define msg_alloc(p) \
+       do { \
+               p = calloc(1, sizeof(*p)); \
+               if (p) { \
+                       p->length = sizeof(*p); \
+               } \
+       } while (0)
+               
+#define msg_length(x) ((x) ? (sizeof(*x) + x->length) : 0)
+#define msg_data(x) ((x->length) ? ((char *)x + sizeof(*x)) : NULL)
+
+#endif /* __SOCKRMMSG_H__ */
diff --git a/ti/runtime/netapi/utils/sockutils.c b/ti/runtime/netapi/utils/sockutils.c
new file mode 100755 (executable)
index 0000000..028c130
--- /dev/null
@@ -0,0 +1,256 @@
+/*
+ * Copyright (C) 2013 Texas Instruments Incorporated - http://www.ti.com/
+ *
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *    Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ *    Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the
+ *    distribution.
+ *
+ *    Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <malloc.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/ioctl.h>
+
+#include "sockutils.h"
+
+#define error_msg printf
+
+typedef struct sock_data {
+    struct sockaddr_un addr;
+    fd_set  readfds;
+    int fd;
+} sock_data_t;
+
+int check_and_create_path (char *path)
+{
+    char *d = path;
+    if (!d)
+        return -1;
+
+    while ((d = strchr(d + 1, '/'))) {
+        *d = 0;
+        if (mkdir(path, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) < 0) {
+            if (errno != EEXIST) {
+                *d = '/';
+                error_msg("can't create path %s (error: %s)",
+                        path, strerror(errno));
+                return -1;
+            }
+        }
+        *d = '/';
+    }
+    return 0;
+}
+
+sock_h sock_open (sock_name_t *sock_name)
+{
+    sock_data_t *sd = 0;
+    int retval = 0;
+
+    if (!sock_name) {
+        return 0;
+    }
+
+    sd = calloc (1, sizeof(sock_data_t));
+
+    if (sock_name->type == sock_addr_e) {
+        memcpy (&sd->addr, sock_name->s.addr, sizeof(struct sockaddr_un));
+    } else {
+        if (check_and_create_path(sock_name->s.name) < 0) {
+            goto check_n_return;
+        }
+        sd->addr.sun_family = AF_UNIX;
+        strncpy(sd->addr.sun_path, sock_name->s.name, UNIX_PATH_MAX);
+    }
+
+    sd->fd =  socket(AF_UNIX, SOCK_DGRAM, 0);
+    if (sd->fd < 0) {
+        error_msg("can't open socket %s (error: %s)",
+                  sd->addr.sun_path, strerror(errno));
+        goto check_n_return;
+    }
+
+    unlink(sd->addr.sun_path);
+    if (bind(sd->fd, (struct sockaddr *) &sd->addr, sizeof(struct sockaddr_un)) < 0) {
+        error_msg("can't bind socket %s (error: %s)",
+                  sd->addr.sun_path, strerror(errno));
+        goto check_n_return;
+    }
+
+    FD_ZERO(&sd->readfds);
+    FD_SET(sd->fd, &sd->readfds);
+
+    retval = (int) sd;
+
+check_n_return:
+    if (!retval) {
+        sock_close ((sock_h) &sd);
+    }
+
+    return ((sock_h) retval);
+}
+
+int sock_close (sock_h handle)
+{
+    sock_data_t *sd = (sock_data_t *) handle;
+
+    if (!sd) {
+        return -1;
+    }
+
+    if (sd->fd)
+        close (sd->fd);
+    free (sd);
+
+    return 0;    
+}
+
+int sock_send (sock_h handle, const char *data, int length,
+            sock_name_t *to)
+{
+    int fd;
+    sock_data_t *sd = (sock_data_t *) handle;
+    struct sockaddr_un to_addr;
+
+    if (!to) {
+        return -1;
+    }
+
+    if (to->type == sock_addr_e) {
+        memcpy (&to_addr, to->s.addr, sizeof(struct sockaddr_un));
+    } else {
+        to_addr.sun_family = AF_UNIX;
+        strncpy(to_addr.sun_path, to->s.name, UNIX_PATH_MAX);
+    }
+
+    if (sd) {
+        fd = sd->fd;
+    } else {
+        fd =  socket(AF_UNIX, SOCK_DGRAM, 0);
+        if (fd < 0) {
+            error_msg("can't open socket %s (error: %s)",
+                      to_addr.sun_path, strerror(errno));
+            return -1;
+        }
+    }
+
+    if (sendto (fd, data, length, 0, (struct sockaddr *) &to_addr,
+                sizeof(struct sockaddr_un)) < 0) {
+        error_msg("can't send data to %s (error: %s)",
+                to_addr.sun_path, strerror(errno));
+        return -1;
+
+    }
+
+    return 0;
+}
+
+int sock_wait (sock_h handle, int *size, struct timeval *timeout, int extern_fd)
+{
+    sock_data_t *sd = (sock_data_t *) handle;
+    int retval;
+    fd_set fds;
+
+    if (!sd) {
+        error_msg("invalid hanlde");
+        return -1;
+    }
+
+    fds = sd->readfds;
+
+    if (extern_fd != -1) {
+        FD_SET(extern_fd, &fds);
+    }
+
+    retval = select(FD_SETSIZE, &fds, NULL, NULL, timeout);
+    if (retval == -1) {
+        error_msg("select failed for %s (error: %s)",
+                sd->addr.sun_path, strerror(errno));
+        return -1;
+    }
+
+    if ((extern_fd != -1) && (FD_ISSET(extern_fd, &fds))) {
+        return 1;
+    }
+
+    if (!FD_ISSET(sd->fd, &fds)) {
+        /* Wait timedout */
+        return -2;
+    }
+
+    if (!retval) {
+        return 0;
+    }
+
+    if (size != 0) {
+        retval = ioctl(sd->fd, FIONREAD, size);
+        if (retval == -1) {
+            error_msg("can't read datagram size for %s (error: %s)",
+                    sd->addr.sun_path, strerror(errno));
+            return -1;
+        }
+    }
+
+    return 0;
+}
+
+int sock_recv (sock_h handle, char *data, int length, sock_name_t *from)
+{
+    int size;
+    sock_data_t *sd = (sock_data_t *) handle;
+    socklen_t from_length = 0;
+
+    if (!sd) {
+        error_msg("invalid hanlde");
+        return -1;
+    }
+
+    if (from) {
+        if((from->type = sock_addr_e) && (from->s.addr))
+            from_length = sizeof(struct sockaddr_un);
+        else {
+            error_msg("invalid from parameter");
+            return -1;
+        }
+    }
+
+    size = recvfrom(sd->fd, data, length, 0, (struct sockaddr *)((from_length) ? from->s.addr : NULL), &from_length);
+    if (size < 1) {
+        error_msg("can't read datagram from socket for %s (error: %s), size %d",
+                sd->addr.sun_path, strerror(errno), size);
+        return -1;
+    }
+
+    return size;
+    
+}
+
diff --git a/ti/runtime/netapi/utils/sockutils.h b/ti/runtime/netapi/utils/sockutils.h
new file mode 100755 (executable)
index 0000000..dc5d811
--- /dev/null
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2013 Texas Instruments Incorporated - http://www.ti.com/
+ *
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *    Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ *    Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the
+ *    distribution.
+ *
+ *    Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+*/
+
+#ifndef __SOCKUTILS_H__
+#define __SOCKUTILS_H__
+
+#include <sys/socket.h>
+#include <sys/un.h>
+
+#ifndef UNIX_PATH_MAX
+#define UNIX_PATH_MAX 108
+#endif
+
+
+typedef enum {
+       sock_name_e,
+       sock_addr_e
+} sock_name_type;
+
+typedef struct {
+       sock_name_type type;
+       union sock {
+               char *name;
+               struct sockaddr_un *addr;
+       } s;
+} sock_name_t;
+
+#define sock_h void *
+
+sock_h sock_open (sock_name_t *sock_name);
+
+int sock_close (sock_h handle);
+
+int sock_send (sock_h handle, const char *data, int length,
+                       sock_name_t *to);
+
+/* Returns: 1 => success (external FD), 0 => success, -1 => error, -2 => timeout */
+int sock_wait (sock_h handle, int *size, struct timeval *timeout, int extern_fd);
+
+int sock_recv (sock_h handle, char *data, int length, sock_name_t *from);
+
+#endif