Multi-proc support in NETAPI changes
authorTinku Mannan <tmannan@ti.com>
Wed, 4 Sep 2013 14:31:02 +0000 (10:31 -0400)
committerTinku Mannan <tmannan@ti.com>
Wed, 4 Sep 2013 14:31:02 +0000 (10:31 -0400)
ti/runtime/netapi/netapi.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/netapi_sec.c
ti/runtime/netapi/src/netcp_cfg.c

index b68513dace82dbece452ae190b11f770335577eb..e8cbd7d6abda512a6d74af3da9b42bd11c78b7d6 100755 (executable)
  *  @ingroup netapi
  */
 
+/**
+ * @def NETAPI_PROC_MASTER
+ *      This defines the master core/thread for a process
+ */
+#define NETAPI_PROC_MASTER 3
+
 /**
  * @def NETAPI_SYS_MASTER
  *      This defines the master core for the system
+ *      also will be master core/thread of the process
  */
-#define NETAPI_SYS_MASTER  2  
+#define NETAPI_SYS_MASTER  2
 
 /**
  * @def NETAPI_CORE_MASTER
  *      This defines the master thread  for a particular core
  */
-#define NETAPI_CORE_MASTER 1  
+#define NETAPI_CORE_MASTER 1
 
 /**
  * @def  NETAPI_NO_MASTER
index ed4baa1fab5681fa4e69d32f48fe08eba9054b1b..4d4b0dc35b73837c1baabf6736ff31e48dd6a61c 100755 (executable)
@@ -70,9 +70,15 @@ unsigned char *netapi_VM_QMemLocalDescRam;
 unsigned char *netapi_VM_QMemGlobalDescRam;
 unsigned char *netapi_VM_SaContextVaddr;
 
+//global for this process that points to the 
+// master thread for this process (either the SYS_MASTER, or PROC_MASTER)
+//...
+NETAPI_HANDLE_T * netapi_proc_master = NULL;
 Pktlib_HeapIfTable  netapi_pktlib_ifTable;
-NETAPI_GLOBAL_T netapi_global;
-NETAPI_GLOBAL_T * netapi_get_global(){ return &netapi_global;}
+NETAPI_PROC_GLOBAL_T netapi_proc_global;
+//NETAPI_GLOBAL_T * netapi_get_global(){ return &netapi_global;}
+NETAPI_GLOBAL_T * netapi_get_global(){ return &pnetapiShm->netapi_global;}
+NETAPI_PROC_GLOBAL_T * netapi_get_proc_global(){ return &netapi_proc_global;}
 
 /* utility API for NETAPI user to get pktlib if table to use if he creates his own heap */
 Pktlib_HeapIfTable *netapi_getPktlibIfTable(void) {return &netapi_pktlib_ifTable;}
@@ -85,7 +91,6 @@ Pktlib_HeapIfTable *netapi_getPktlibIfTable(void) {return &netapi_pktlib_ifTable
  ********************************************************************/
 NETAPI_T netapi_init(int master, NETAPI_CFG_T * p_cfg)
 {
-    static int first_time = HPLIB_TRUE;
     int i;
     int err;
     int exception_id = 7;
@@ -97,7 +102,7 @@ NETAPI_T netapi_init(int master, NETAPI_CFG_T * p_cfg)
     if (!p) return NULL;
     p->master = master;
 
-    /* The following segment should be done 1 Time per system boot by global master process */
+    /*  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)
     {
         pBase = hplib_shmCreate(HPLIB_SHM_SIZE);
@@ -120,10 +125,21 @@ NETAPI_T netapi_init(int master, NETAPI_CFG_T * p_cfg)
         {
             netapi_Log("netapi_init: hplib_shmAddEntry sucess for NETAPI_ENTRY\n");
         }
-        Osal_create(first_time);
+        Osal_create();
+    }
+    /*ALL others:  we are not the system master; assume SYS_MASTER has
+      created SHM area for us already, so just open it */
+    else 
+    {
+        pBase = hplib_shmOpen(HPLIB_SHM_SIZE);
+        //error check;  
+        if (!pBase)
+        {
+            netapi_Log("netapi_init: hplib_shmOpen error\n");
+        }
     }
 
-    /* create space for our local pktios */
+    /*ALL:  create space for our local pktios */
     for(i=0;i<TUNE_NETAPI_MAX_PKTIO; i++)
     {
         p->pktios[i] = calloc(1,sizeof(PKTIO_HANDLE_T));
@@ -134,7 +150,7 @@ NETAPI_T netapi_init(int master, NETAPI_CFG_T * p_cfg)
     }
 
 #ifdef NETAPI_INCLUDE_SCHED
-    /* create space for scheduler */
+    /* ALL: create space for scheduler */
     p->p_sched = calloc(1,sizeof(NETAPI_SCHED_HANDLE_T));
     if (!p->p_sched)
     {
@@ -142,77 +158,92 @@ NETAPI_T netapi_init(int master, NETAPI_CFG_T * p_cfg)
     }
 #endif
 
-    /* The following segment should be done 1 Time per system boot by global master process */
-    if (master==NETAPI_SYS_MASTER)
+    /* SYS_MASTER:  The following segment should be done 1 Time per system boot by global master process */
+    if (master == NETAPI_SYS_MASTER)
     {
-        pnetapiShm = (NETAPI_SHM_T*)hplib_shmGetEntry(pBase, NETAPI_ENTRY);
         pnetapiShm = (NETAPI_SHM_T*)hplib_shmGetEntry(pBase, NETAPI_ENTRY);
         pnetapiShm->netapi_pktio_lock= hplib_spinLock_UNLOCKED_INITIALIZER;
         pnetapiShm->netapi_netcp_cfg_lock = hplib_spinLock_UNLOCKED_INITIALIZER;
         pnetapiShm->netapi_util_lock = hplib_spinLock_UNLOCKED_INITIALIZER;
         if (p_cfg)
         {
-            memcpy(&netapi_global.cfg,p_cfg, sizeof(NETAPI_CFG_T));
+            memcpy(&pnetapiShm->netapi_global.cfg,p_cfg, sizeof(NETAPI_CFG_T));
         }
         else
         {
-            memcpy(&netapi_global.cfg,&netapi_default_cfg, sizeof(NETAPI_CFG_T));
+            memcpy(&pnetapiShm->netapi_global.cfg,&netapi_default_cfg, sizeof(NETAPI_CFG_T));
         }
         for(i=0;i<TUNE_NETAPI_MAX_PKTIO;i++) 
         {
-            netapi_global.pktios[i].qn.qNum=-1;
-            netapi_global.pktios[i].name[0]='\0';
+            pnetapiShm->netapi_global.pktios[i].qn.qNum=-1;
+            pnetapiShm->netapi_global.pktios[i].name[0]='\0';
         }
     }
-    //this goes to shared memory eventually
-    p->global = (void *) &netapi_global;
+    else
+    {
+        /* other 'masters' will just get a pointer to the netapi SHM area*/
+        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
+    p->global = (void *) &pnetapiShm->netapi_global;
+    p->proc_global = (void *)&netapi_proc_global;
 
-    /* The following segment should be done 1 Time per system boot by global master process 
-       save master's handle back in global; else for slave retrieve p_master */
-    if (master==NETAPI_SYS_MASTER)
+    /* SYS_MASTER, PROC_MASTER: save a pointer to its netapi structure
+       globably for other threads/core of process to use */
+    if ((master == NETAPI_SYS_MASTER)||(master == NETAPI_PROC_MASTER))
     {
-        netapi_global.p_master = p;
+        p_master=netapi_proc_master = p;
     }
     else
     {
-        /* get system master reqquired for core and no master */
-        p_master=(NETAPI_HANDLE_T *)netapi_global.p_master;
+        /* CORE_MASTER/NO_MASTER: get system master/proc master's handle */
+        p_master=(NETAPI_HANDLE_T *) netapi_proc_master;
     }
 
-    /* The following segment should be done 1 Time per system boot by global master process */
+    /* SYS_MASTER: The following segment should be done 1 Time per system boot by global master process */
     /* system init */
-    if(master==NETAPI_SYS_MASTER)
+    if(master == NETAPI_SYS_MASTER)
     {
         err = netapip_systemInit(p, TRUE);
-        netapi_netcpCfgExceptions(p, NETCP_CFG_ALL_EXCEPTIONS, NETCP_CFG_ACTION_TO_SW, (NETCP_CFG_ROUTE_HANDLE_T) NULL);
         if (err<0) 
         {
             goto ERR_netapi_init;
         }
-    /* create pktio channels for tx,rx */
+        netapi_netcpCfgExceptions(p, NETCP_CFG_ALL_EXCEPTIONS, NETCP_CFG_ACTION_TO_SW, (NETCP_CFG_ROUTE_HANDLE_T) NULL);
+    }
+    /* PROC_MASTER case */
+    else if (master==NETAPI_PROC_MASTER)
+    {
+        err = netapip_systemInit(p, FALSE); //more limited initialization
+        if (err<0)
+        {
+            goto ERR_netapi_init;
+        }
     }
-    else if (master==NETAPI_NO_MASTER)
+    /* NO_MASTER:  case */
+    else if (master == NETAPI_NO_MASTER)
     {
-        /*Just copy master's packetio list for now */
+        /*Just copy master's pktio list for now */
         p->n_pktios = p_master->n_pktios;
         memcpy(&p->pktios[0],&p_master->pktios[0],TUNE_NETAPI_MAX_PKTIO*sizeof(PKTIO_HANDLE_T));
         p->nwal_local=p_master->nwal_local;
     }
     /* this is the NETAPI_CORE_MASTER case */
-     else if (master==NETAPI_CORE_MASTER)
+    else if (master == NETAPI_CORE_MASTER)
     {
-
         /* Start the QMSS. */
         if (netapip_startQm() != 1)
         {
             goto ERR_netapi_init;
         }
         netapip_startNwal(p_master->netcp_heap, 
-                                       p_master->netcp_control_rx_heap,
-                                       p_master->netcp_control_tx_heap, 
+                          p_master->netcp_control_rx_heap,
+                          p_master->netcp_control_tx_heap, 
                                        &p->nwal_local,
-                                       &netapi_global.cfg,
-                                       &netapi_global.nwal_context);
+                          &pnetapiShm->netapi_global.cfg,
+                          &pnetapiShm->netapi_global.nwal_context);
     }
     else
     {
@@ -222,6 +253,7 @@ NETAPI_T netapi_init(int master, NETAPI_CFG_T * p_cfg)
 
     return (NETAPI_T) p;
 
+/* error handling */
 ERR_netapi_init:
     for(i=0;i<TUNE_NETAPI_MAX_PKTIO; i++)
     {
@@ -258,8 +290,14 @@ void netapi_shutdown(NETAPI_T h)
     netapi_Log("netapi: WARNING shutdown may not be fully implemented\n");
     if (p->master ==NETAPI_SYS_MASTER)
     {
-        /* close nwal */
-        nwal_delete(netapi_global.nwal_context.nwalInstHandle);
+        /* Un-configure rules for execption packet handling */
+        netapi_netcpCfgExceptions(p,
+                              NETCP_CFG_ALL_EXCEPTIONS,
+                              NETCP_CFG_ACTION_DISCARD,
+                              (NETCP_CFG_ROUTE_HANDLE_T) NULL);
+
+        /* close nwal master (per soc) context */
+        nwal_delete(pnetapiShm->netapi_global.nwal_context.nwalInstHandle);
 
         /* close heaps */
         netapi_closeHeap(h, p->netcp_heap);
@@ -268,29 +306,49 @@ void netapi_shutdown(NETAPI_T h)
         netapi_closeHeap(h, netapi_get_global()->nwal_context.pa2sa_heap); 
         netapi_closeHeap(h, netapi_get_global()->nwal_context.sa2pa_heap); 
 
-        /* Un-configure rules for execption packet handling */
-        netapi_netcpCfgExceptions(p,
-                              NETCP_CFG_ALL_EXCEPTIONS,
-                              NETCP_CFG_ACTION_DISCARD,
-                              (NETCP_CFG_ROUTE_HANDLE_T) NULL);
         //loop over registered heaps
         for(i=0;i<TUNE_NETAPI_MAX_HEAPS;i++)
         {
             if (p->createdHeaps[i])  {netapi_closeHeap(h,p->createdHeaps[i]);p->createdHeaps[i]=NULL;}
         }
         netapip_cleanupAtStart();  //clear 1st 50 not-specified queues
-
-        map_base = (void *) hplib_utilGetVaOfBufferArea(HPLIBMOD_MMAP_DMA_MEM_OFFSET, 0);
-        if (map_base)
-        {
-            poolHdr = (hplib_VirtMemPoolheader_T*)map_base;
-            poolHdr->ref_count = 0;
-            poolHdr->virtMemAllocOffset = 0;
-        }
+        //reset DDR malloc area
+        hplib_resetMallocArea(0);
         hplib_vmTeardown();
         printf("netapi_shutdown: calling hplib_shmDelete\n");
         hplib_shmDelete();
     }
+    else if (p->master==NETAPI_PROC_MASTER)
+    {
+        //we can zap these because they are local to our process
+        netapi_closeHeap(h, p->netcp_control_rx_heap);
+        netapi_closeHeap(h, p->netcp_control_tx_heap);
+        //loop over registered heaps (again local to our process)
+        for(i=0;i<TUNE_NETAPI_MAX_HEAPS;i++)
+        {
+            if (p->createdHeaps[i])  {netapi_closeHeap(h,p->createdHeaps[i]);p->createdHeaps[i]=NULL;}
+        }
+        hplib_vmTeardown();
+    }
+    //TODO other master types
+    /* error handling */
+    
+    for(i=0;i<TUNE_NETAPI_MAX_PKTIO; i++)
+    {
+        if (p->pktios[i])
+        {
+            free(p->pktios[i]);
+            p->pktios[i] = NULL;
+        }
+    }
+#ifdef NETAPI_INCLUDE_SCHED
+    if (p->p_sched)
+    {
+        free(p->p_sched);
+        p->p_sched = NULL;
+    }
+#endif
+
     free(p);
     return;
 }
index 48ccd95ccb79e7f32dd312367989aa806784345f..548d5bd729642580b489343858a90f49bf9db87e 100755 (executable)
@@ -83,7 +83,7 @@ extern unsigned char *netapi_VM_QMemGlobalDescRam;
 extern unsigned char *netapi_VM_SaContextVaddr;
 
 extern Pktlib_HeapIfTable  netapi_pktlib_ifTable;
-extern NETAPI_GLOBAL_T netapi_global;
+extern NETAPI_PROC_GLOBAL_T netapi_proc_global;
 
 
 /* TODO verify: */
@@ -565,7 +565,7 @@ int netapip_initTimer(void)
 
 static uint8_t* netapip_sharedMemoryMalloc(uint32_t size)
 {
-return  (uint8_t *)hplib_vmMemAlloc(size +netapi_global.cfg.def_heap_extra_size , 128, 0); 
+return  (uint8_t *)hplib_vmMemAlloc(size +pnetapiShm->netapi_global.cfg.def_heap_extra_size , 128, 0); 
 }
 
 /********************************************************************
@@ -646,20 +646,71 @@ int netapip_systemInit(NETAPI_HANDLE_T * handle, Bool global_master_process)
 
     if (global_master_process == TRUE)
     {
-        hplibp_initMallocArea(0);
-        hplibp_initMallocArea(1);
+        hplib_initMallocArea(0);
+        hplib_initMallocArea(1);
     }
     else
     {
-        if (hplibp_checkMallocArea(0) != hplib_OK)
+        if (hplib_checkMallocArea(0) != hplib_OK)
             return -1;
-        if (hplibp_checkMallocArea(1) != hplib_OK)
+        if (hplib_checkMallocArea(1) != hplib_OK)
             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
+        //------------------------------------------------
+       
+/* Start the QMSS. */
+       if (netapip_startQm() != 1)
+       {
+          netapi_Log("netapip_systemInit: returned from netapip_startQm with failure\n");
+          return -1;
+       }
+
+        //open shared heap handle but create new controlRx & Tx heaps for this
+        //process
+        netapi_pktlib_ifTable.data_malloc  = netapip_sharedMemoryMalloc;
+        netapi_pktlib_ifTable.data_free    = netapip_sharedMemoryFree;
+        sharedHeapHandle = Pktlib_findHeapByName("netapi");
+        if (!sharedHeapHandle) { netapi_Log(">'netapi' heap create failed, Error Code: %d\n",errCode); return -1;}
+        handle->netcp_heap= sharedHeapHandle;
+
+        /* Update for Control */
+        heapCfg.name                = "netapi_control_rx";/*todo:add random#*/
+        heapCfg.sharedHeap          = 1;
+        heapCfg.dataBufferSize      = TUNE_NETAPI_CONFIG_MAX_CTL_RXTX_BUF_SIZE;
+        heapCfg.numPkts             = TUNE_NETAPI_CONFIG_NUM_CTL_RX_BUF;
+        heapCfg.numZeroBufferPackets= 0;
+        controlRxHeapHandle = Pktlib_createHeap(&heapCfg, &errCode);
+        if (!controlRxHeapHandle) { netapi_Log("netapi -'netapi_control_rx' heap create failed, Error Code: %d\n",errCode); return -1;}
+        handle->netcp_control_rx_heap= controlRxHeapHandle;
+        heapCfg.name                = "netapi_control_tx";
+        heapCfg.numPkts             = TUNE_NETAPI_CONFIG_NUM_CTL_TX_BUF;
+        controlTxHeapHandle = Pktlib_createHeap(&heapCfg, &errCode);
+        if (!controlTxHeapHandle) { netapi_Log("netapi -'netapi_control_tx' heap create failed, Error Code: %d\n",errCode); return -1;}
+        handle->netcp_control_tx_heap= controlTxHeapHandle;
+
+        /* Common Initialization for all threads in process */
+        while(count < TUNE_NETAPI_MAX_NUM_TRANS)
+        {
+          netapi_proc_global.nwal_context.transInfos[count].transId = count;
+          count++;
+        }
+        result = netapip_startNwal(sharedHeapHandle,
+                               controlRxHeapHandle,
+                               controlTxHeapHandle,
+                               &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");
+    }
 
 #ifdef NETAPI_ENABLE_SECURITY
 #define SEC_CONTEXT_SZ 384  //not tunable
@@ -698,7 +749,7 @@ int netapip_systemInit(NETAPI_HANDLE_T * handle, Bool global_master_process)
 #endif
 
     /* Initialize Queue Manager Sub System */
-    result = netapip_initQm (netapi_global.cfg.def_max_descriptors); 
+    result = netapip_initQm (pnetapiShm->netapi_global.cfg.def_max_descriptors); 
     
     if (result != 1)
     {
@@ -719,7 +770,7 @@ int netapip_systemInit(NETAPI_HANDLE_T * handle, Bool global_master_process)
  netapi_Log("netapip_systemInit: returned from netapip_cleanupAtStart\n");
     /* Initialize the global descriptor memory region. */
     result= netapip_qmSetupMemRegion( 
-                      netapi_global.cfg.def_tot_descriptors_for_us,
+                      pnetapiShm->netapi_global.cfg.def_tot_descriptors_for_us,
                       TUNE_NETAPI_DESC_SIZE,
                       (unsigned int *) netapi_VM_QMemGlobalDescRam,
                       TUNE_NETAPI_QM_GLOBAL_REGION);
@@ -754,9 +805,9 @@ netapi_Log("netapip_systemInit: returned from netapip_qmSetupMemRegion\n");
     heapCfg.memRegion           = TUNE_NETAPI_QM_GLOBAL_REGION;
     heapCfg.sharedHeap          = 1;
     heapCfg.useStarvationQueue  = 0;
-    heapCfg.dataBufferSize      = netapi_global.cfg.def_heap_buf_size;
-    heapCfg.numPkts             = netapi_global.cfg.def_heap_n_descriptors;
-    heapCfg.numZeroBufferPackets= netapi_global.cfg.def_heap_n_zdescriptors;
+    heapCfg.dataBufferSize      = pnetapiShm->netapi_global.cfg.def_heap_buf_size;
+    heapCfg.numPkts             = pnetapiShm->netapi_global.cfg.def_heap_n_descriptors;
+    heapCfg.numZeroBufferPackets= pnetapiShm->netapi_global.cfg.def_heap_n_zdescriptors;
     heapCfg.heapInterfaceTable.data_malloc  = netapi_pktlib_ifTable.data_malloc;
     heapCfg.heapInterfaceTable.data_free    = netapi_pktlib_ifTable.data_free;
     heapCfg.dataBufferPktThreshold   = 0;
@@ -796,8 +847,8 @@ netapi_Log("netapip_systemInit: returned from netapip_qmSetupMemRegion\n");
     result = netapip_initNwal(
                               TUNE_NETAPI_QM_GLOBAL_REGION,
                               &netapi_pktlib_ifTable, 
-                              &netapi_global.nwal_context,
-                              &netapi_global.cfg);
+                              &pnetapiShm->netapi_global.nwal_context,
+                              &pnetapiShm->netapi_global.cfg);
     if (result<0) {netapi_Log("netapi  init_nwal() failed\n"); return -1; }
  netapi_Log("netapip_systemInit: returned from netapip_initNwal\n");
     /* start NWAL */
@@ -806,15 +857,15 @@ netapi_Log("netapip_systemInit: returned from netapip_qmSetupMemRegion\n");
     /* Common Initialization for all cores */
     while(count < TUNE_NETAPI_MAX_NUM_TRANS)
     {
-        netapi_global.nwal_context.transInfos[count].transId = count;
+        netapi_proc_global.nwal_context.transInfos[count].transId = count;
         count++;
     }
     result = netapip_startNwal(sharedHeapHandle, 
                                controlRxHeapHandle,
                                controlTxHeapHandle,
                                &handle->nwal_local,
-                               &netapi_global.cfg,
-                               &netapi_global.nwal_context);
+                               &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");
     return 0;
index 52a53b0063aa4bc02f664c8e215903baa5b3f492..3358d509c5f24f3bfc851256d0ba83294131c53b 100755 (executable)
@@ -122,8 +122,8 @@ typedef struct NETCP_REGISTERED_FLOWS_Tag
 } NETCP_REGISTERED_FLOWS_T;
 
 /******************************
- *    nwal global context 
- *  (shared over all instances)
+ *    nwal global context : for SOC
+ *  (shared over all process instances)
  *******************************/
 typedef struct
 {
@@ -132,16 +132,12 @@ typedef struct
 #define NETAPI__CXT_GLOB_ACTIVE                   0x1
 #define NETAPI_NW_CXT_GLOB_RES_ALLOC_COMPLETE     0x3
 
-    nwal_Handle                     nwalInstHandle;
+    nwal_Handle                     nwalInstHandle;  //created instance 
     //internal heaps used just by netcp (sa<->pa). SW doesn't touch these
     Pktlib_HeapHandle               sa2pa_heap;
     Pktlib_HeapHandle               pa2sa_heap;
     //stats
     paSysStats_t                    paStats;
-    int                             numCmdPass;
-    int                             numCmdFail;
-    int                             numBogusTransIds;
-    NetapiNwalTransInfo_t           transInfos[TUNE_NETAPI_MAX_NUM_TRANS];     //transactions
     NETCP_INTERFACE_T               interfaces[TUNE_NETAPI_MAX_NUM_MAC];        //interfaces
     NETCP_INTERFACE_CLASSIFIER_T    classi[TUNE_NETAPI_MAX_CLASSIFIERS]; //classifiers
     NETCP_REGISTERED_FLOWS_T        flows[TUNE_NETAPI_MAX_FLOWS]; //flows
@@ -149,6 +145,17 @@ typedef struct
     NETCP_IPSEC_POLICY_T            policy[TUNE_NETAPI_MAX_POLICY];  //policies
     NETCP_INTERFACE_IP_T            ips[TUNE_NETAPI_MAX_NUM_IP];           //ips
 } NETAPI_NWAL_GLOBAL_CONTEXT_T;
+/************************************/
+/* global instance for this process */
+/************************************/
+typedef struct
+{
+    int                             state; /* see above*/
+    int                             numCmdPass;
+    int                             numCmdFail;
+    int                             numBogusTransIds;
+    NetapiNwalTransInfo_t           transInfos[TUNE_NETAPI_MAX_NUM_TRANS]; 
+} NETAPI_NWAL_GLOBAL_PROC_CONTEXT_T;
 
 /* NWAL Local context (per core/thread)  */
 typedef struct
@@ -171,7 +178,7 @@ typedef struct
     nwalLocCfg_t           nwalLocCfg;
 } NETAPI_NWAL_LOCAL_CONTEXT_T;
 
-/* the global */
+/* the global: for SOC, accross all processes */
 typedef struct NETAPI_GLOBAL_tag
 {
 #define NETAPI_MAX_PKTIO (TUNE_NETAPI_MAX_PKTIO) 
@@ -180,10 +187,17 @@ typedef struct NETAPI_GLOBAL_tag
     NETAPI_CFG_T                    cfg;
     /* nwal context */
     NETAPI_NWAL_GLOBAL_CONTEXT_T    nwal_context;
-    NETAPI_T                        p_master;  // save p'masters handle 
+    //NETAPI_T                        p_master;  // save p'masters handle 
 } NETAPI_GLOBAL_T;
 
+/* the process global: one per process */
+typedef struct NETAPI_PROC_GLOBAL_tag
+{
+    /* nwal context */
+    NETAPI_NWAL_GLOBAL_PROC_CONTEXT_T    nwal_context;
 
+    //NETAPI_T                        p_master;  // save p'masters handle 
+} NETAPI_PROC_GLOBAL_T;
 /************************************
  * this is a per thread structure.
  * It contains stuff local to thread
@@ -194,7 +208,8 @@ typedef struct NETAPI_HANDLE_Tag
 {
     int                         master; //master type
 
-    void*                       global;  /* pointer to the global area */
+    void*                       global;  /* pointer to the soc global area */
+    void*                       proc_global;  /* pointer to the proc global area */
 
     /* heap  handles */
     Pktlib_HeapHandle           netcp_heap;    /* internal default */
@@ -291,6 +306,7 @@ static inline void * netapi_get_scheduler(NETAPI_T p)
 
 /* return pointer to global area */
 NETAPI_GLOBAL_T * netapi_get_global(void);
+NETAPI_PROC_GLOBAL_T * netapi_get_proc_global(void);
 
 //add a pktio name (and queue) to global list
 static inline int  netapip_addGlobalPktio(NETAPI_T p, char *name, Qmss_Queue * qn)
@@ -388,7 +404,7 @@ void netapip_netcpCfgInsertSa(NETAPI_NWAL_GLOBAL_CONTEXT_T *p,
 void *netapip_netcpCfgGetSaHandles( NETAPI_NWAL_GLOBAL_CONTEXT_T *p,
                           int sa_slot, void ** p_sideband);
 void* netapip_netcpCfgGetMacHandle(NETAPI_NWAL_GLOBAL_CONTEXT_T *p,int iface_no);
-NetapiNwalTransInfo_t *  netapip_getFreeTransInfo(NETAPI_GLOBAL_T *p_global, nwal_TransID_t *pTransId);
+NetapiNwalTransInfo_t *  netapip_getFreeTransInfo(NETAPI_PROC_GLOBAL_T *p_global, nwal_TransID_t *pTransId);
 void netapip_freeTransInfo(NetapiNwalTransInfo_t* pTransInfo);
 void *netapip_netcpCfgGetPolicy( NETAPI_NWAL_GLOBAL_CONTEXT_T *p,
                           int policy_slot);
index d9ee3193a163d8e38ff715ff9b8f1a77ea535625..ceec93e3a2cd84379c69036d00ce77e3be86bab7 100755 (executable)
@@ -125,7 +125,7 @@ NETCP_CFG_SA_T netapi_secAddSA(NETAPI_T h,
 
     if (inflow_mode & NETAPI_SEC_SA_INFLOW)
     {
-        pTransInfo = netapip_getFreeTransInfo((NETAPI_GLOBAL_T *) n->global, &trans_id);
+        pTransInfo = netapip_getFreeTransInfo((NETAPI_PROC_GLOBAL_T *) n->proc_global, &trans_id);
         if (!pTransInfo)
         {
             *perr =  NETAPI_ERR_BUSY;
@@ -347,7 +347,7 @@ static void netapi_secDelSA_internal(NETAPI_T h,
     if(handle_inflow)
     {
     /* get a transaction id */
-        pTransInfo = netapip_getFreeTransInfo((NETAPI_GLOBAL_T *) n->global, &trans_id);
+        pTransInfo = netapip_getFreeTransInfo((NETAPI_PROC_GLOBAL_T *) n->proc_global, &trans_id);
         if (!pTransInfo)
         {
             *perr =  NETAPI_ERR_BUSY;
@@ -487,7 +487,7 @@ NETCP_CFG_IPSEC_POLICY_T netapi_secAddRxPolicy(NETAPI_T h,
     }
 
     /* get a transaction id */
-    pTransInfo = netapip_getFreeTransInfo((NETAPI_GLOBAL_T *) n->global, &trans_id);
+    pTransInfo = netapip_getFreeTransInfo((NETAPI_PROC_GLOBAL_T *) n->proc_global, &trans_id);
     if (!pTransInfo)
     {
         *perr =  NETAPI_ERR_BUSY;
@@ -592,7 +592,7 @@ static void netapi_secDelRxPolicy_internal(NETAPI_T h,
     *perr =0;
 
     /* get a transaction id */
-    pTransInfo = netapip_getFreeTransInfo((NETAPI_GLOBAL_T *) n->global, &trans_id);
+    pTransInfo = netapip_getFreeTransInfo((NETAPI_PROC_GLOBAL_T *) n->proc_global, &trans_id);
     if (!pTransInfo)
     {
         *perr =  NETAPI_ERR_BUSY;
index eaab5c258cfb9a6cde2e906c3a3b5d020c11f1b2..e8bcc5dd4b12c32bad775ec3d905d56794489775 100755 (executable)
@@ -55,7 +55,7 @@ extern NETAPI_SHM_T* pnetapiShm;
  ********************************************************************
  * DESCRIPTION:  Netapi internal function to get a free transaction id.
  ********************************************************************/
-NetapiNwalTransInfo_t * netapip_getFreeTransInfo(NETAPI_GLOBAL_T *p_global,
+NetapiNwalTransInfo_t * netapip_getFreeTransInfo(NETAPI_PROC_GLOBAL_T *p_proc_global,
                                                  nwal_TransID_t *pTransId)
 {
     uint16_t    count=0;
@@ -64,12 +64,12 @@ NetapiNwalTransInfo_t * netapip_getFreeTransInfo(NETAPI_GLOBAL_T *p_global,
     hplib_mSpinLockLock(&pnetapiShm->netapi_netcp_cfg_lock);
     while(count < TUNE_NETAPI_MAX_NUM_TRANS)
     {
-        if((p_global->nwal_context.transInfos[count].inUse) != nwal_TRUE)
+        if((p_proc_global->nwal_context.transInfos[count].inUse) != nwal_TRUE)
         {
-            p_global->nwal_context.transInfos[count].inUse = nwal_TRUE;
+            p_proc_global->nwal_context.transInfos[count].inUse = nwal_TRUE;
             *pTransId = count;
             hplib_mSpinLockUnlock(&pnetapiShm->netapi_netcp_cfg_lock);
-            return(&p_global->nwal_context.transInfos[count]);
+            return(&p_proc_global->nwal_context.transInfos[count]);
         }
         count++;
     }
@@ -698,7 +698,7 @@ void netapi_netcpCfgReqStats(NETAPI_T  h,
     }
     *err =0;
 
-    pTransInfo = netapip_getFreeTransInfo((NETAPI_GLOBAL_T *) n->global, &transId);
+    pTransInfo = netapip_getFreeTransInfo((NETAPI_PROC_GLOBAL_T *) n->proc_global, &transId);
     if (!pTransInfo) { *err =  NETAPI_ERR_BUSY; return ;}
     pTransInfo->transType = NETAPI_NWAL_HANDLE_STAT_REQUEST;
     pTransInfo->netapi_handle = h;
@@ -749,7 +749,7 @@ NETCP_CFG_MACIF_T  netapi_netcpCfgCreateMacInterface(NETAPI_T  h,
     if ((!n) || (!p_mac)) {*err = NETAPI_ERR_BAD_INPUT; return -1;}
     *err =0;
 
-    pTransInfo = netapip_getFreeTransInfo((NETAPI_GLOBAL_T *) n->global, &trans_id);
+    pTransInfo = netapip_getFreeTransInfo((NETAPI_PROC_GLOBAL_T *) n->proc_global, &trans_id);
     if (!pTransInfo)
     {
         *err =  NETAPI_ERR_BUSY;
@@ -841,7 +841,7 @@ void netapi_netcpCfgDelMac(NETAPI_T h,
     *err =0;
 
     //get a transaction id
-    pTransInfo = netapip_getFreeTransInfo((NETAPI_GLOBAL_T *) n->global, &trans_id);
+    pTransInfo = netapip_getFreeTransInfo((NETAPI_PROC_GLOBAL_T *) n->proc_global, &trans_id);
     if (!pTransInfo)
     {
         *err =  NETAPI_ERR_BUSY;
@@ -962,7 +962,7 @@ static NETCP_CFG_IP_T  netapip_netcpCfgAddIpInternal(NETAPI_T  h,
     }
 
     //get a transaction object for config action
-    pTransInfo = netapip_getFreeTransInfo((NETAPI_GLOBAL_T *) n->global, &trans_id);
+    pTransInfo = netapip_getFreeTransInfo((NETAPI_PROC_GLOBAL_T *) n->proc_global, &trans_id);
     if (!pTransInfo)
     {
         *err =  NETAPI_ERR_BUSY;
@@ -1113,7 +1113,7 @@ static void netapip_netcpCfgDelIpInternal(NETAPI_T h,
     *err =0;
 
     //get a transaction id
-    pTransInfo = netapip_getFreeTransInfo((NETAPI_GLOBAL_T *) n->global, &trans_id);
+    pTransInfo = netapip_getFreeTransInfo((NETAPI_PROC_GLOBAL_T *) n->proc_global, &trans_id);
     if (!pTransInfo)
     {
         *err =  NETAPI_ERR_BUSY;
@@ -1337,7 +1337,7 @@ NETCP_CFG_CLASS_T netapi_netcpCfgAddClass(NETAPI_T                  h,
 
 
             //get a transaction id
-            pTransInfo = netapip_getFreeTransInfo((NETAPI_GLOBAL_T *) n->global, &trans_id);
+            pTransInfo = netapip_getFreeTransInfo((NETAPI_PROC_GLOBAL_T *) n->proc_global, &trans_id);
             if (!pTransInfo)
             {
                 *err =  NETAPI_ERR_BUSY; 
@@ -1432,7 +1432,7 @@ void netapi_netcpCfgDelClass(NETAPI_T           h,
                         &netapi_get_global()->nwal_context,
                         class_slot );
     //get a transaction id
-    pTransInfo = netapip_getFreeTransInfo((NETAPI_GLOBAL_T *) n->global, &trans_id);
+    pTransInfo = netapip_getFreeTransInfo((NETAPI_PROC_GLOBAL_T *) n->proc_global, &trans_id);
     if (!pTransInfo)
     {
         *err =  NETAPI_ERR_BUSY; 
@@ -1719,11 +1719,11 @@ void netapip_netcpCfgNWALCmdCallBack(nwal_AppId        appHandle,
 
     if(trans_id == NWAL_TRANSID_SPIN_WAIT)
     {
-        netapi_get_global()->nwal_context.numBogusTransIds++;
+        netapi_get_proc_global()->nwal_context.numBogusTransIds++;
         return;
     }
 
-    p_trans= &netapi_get_global()->nwal_context.transInfos[trans_id];
+    p_trans= &netapi_get_proc_global()->nwal_context.transInfos[trans_id];
     p_local =&((NETAPI_HANDLE_T*) (p_trans->netapi_handle))->nwal_local;
 
     if(ret != nwal_OK)
@@ -1733,12 +1733,12 @@ void netapip_netcpCfgNWALCmdCallBack(nwal_AppId        appHandle,
         // update error code that is fialed  in p_trans */
         //todo: atomic inc
         p_trans->state = NETAPI_NWAL_HANDLE_STATE_ERR;
-        netapi_get_global()->nwal_context.numCmdFail++;
+        netapi_get_proc_global()->nwal_context.numCmdFail++;
     }
     else
     {
         //todo: atomic inc
-        netapi_get_global()->nwal_context.numCmdPass++;
+        netapi_get_proc_global()->nwal_context.numCmdPass++;
         switch(p_trans->transType)
         {
             case NETAPI_NWAL_HANDLE_TRANS_MAC:
@@ -1833,11 +1833,11 @@ void netapip_netcpCfgNWALCmdPaStatsReply(nwal_AppId        appHandle,
 
     if(trans_id == NWAL_TRANSID_SPIN_WAIT)
     {
-        netapi_get_global()->nwal_context.numBogusTransIds++;
+        netapi_get_proc_global()->nwal_context.numBogusTransIds++;
         return;
     }
 
-    p_trans= &netapi_get_global()->nwal_context.transInfos[trans_id];
+    p_trans= &netapi_get_proc_global()->nwal_context.transInfos[trans_id];
     p_trans->inUse = nwal_FALSE;
     p_local =&((NETAPI_HANDLE_T*) (p_trans->netapi_handle))->nwal_local;