dmm initial commit

Change-Id: I049ee277cf4efdb83f9c2ac439365fcd421c159b
Signed-off-by: qchang <qing.chang1@huawei.com>

1 files changed, 880 insertions, 0 deletions

diff --git a/src/framework/common/mem_mgr/nsfw_shmem/nsfw_shmem_mng.c b/src/framework/common/mem_mgr/nsfw_shmem/nsfw_shmem_mng.c
new file mode 100644
index 0000000..f85e70d
--- /dev/null
+++ b/src/framework/common/mem_mgr/nsfw_shmem/nsfw_shmem_mng.c
@@ -0,0 +1,880 @@
+/*
+*
+* Copyright (c) 2018 Huawei Technologies Co.,Ltd.
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at:
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#include "nstack_securec.h"
+#include "nstack_log.h"
+#include "nsfw_mem_desc.h"
+#include "nsfw_ring_fun.h"
+#include "nsfw_shmem_ring.h"
+#include "nsfw_shmem_mng.h"
+#include "common_mem_mempool.h"
+#include "common_mem_memzone.h"
+#include "common_mem_buf.h"
+#include "common_mem_mbuf.h"
+#include "nsfw_rshmem_mng.h"
+#include "common_mem_api.h"
+#include "common_sys_config.h"
+#include "nsfw_maintain_api.h"
+#include "common_pal_bitwide_adjust.h"
+
+#include "common_mem_pal.h"
+
+#include "common_func.h"
+
+#define NSFW_SHMEM_PID    (get_sys_pid())
+#define NSFW_SHMEM_FLAG   (g_shmem_localdata->enflag)
+
+nsfw_mem_localdata *g_shmem_localdata = NULL;
+
+/*check g_mem_localdata*/
+#define NSFW_INIT_CHK_RET() \
+    if (!g_shmem_localdata) \
+    { \
+        return NSFW_MEM_ERR; \
+    }
+
+#define NSFW_INIT_CHK_RET_NULL() \
+    if (!g_shmem_localdata) \
+    { \
+        return NULL; \
+    }
+
+/*
+ *share memory mng module init
+ *
+ */
+i32
+nsfw_shmem_init (nsfw_mem_para * para)
+{
+  common_mem_pal_module_info rteinfo = { 0 };
+  i32 iret = NSFW_MEM_ERR;
+  int flag = 0;
+  if (!para)
+    {
+      return NSFW_MEM_ERR;
+    }
+
+  NSCOMM_LOGINF ("nsfw shmem init begin");
+
+  if (NSFW_PROC_MASTER == para->enflag)
+    {
+      iret = common_mem_pal_init (para->iargsnum, para->pargs);
+    }
+  else if (NSFW_PROC_MAIN == para->enflag)
+    {
+      iret = common_pal_module_init (NULL);
+    }
+  else
+    {
+      LCORE_MASK_SET (rteinfo.ilcoremask, 1);
+      rteinfo.ucproctype = DMM_PROC_T_SECONDARY;
+      iret = common_pal_module_init (&rteinfo);
+    }
+
+  if (NSFW_MEM_OK != iret)
+    {
+      NSCOMM_LOGERR ("rte init fail] ret=0x%x", iret);
+      return NSFW_MEM_ERR;
+    }
+
+  flag = dmm_pal_addr_align ();
+  if ((0 == flag) && (NSFW_PROC_MAIN == para->enflag))
+    {
+      dmm_addr_print ();
+      NSCOMM_LOGERR
+        ("rte init addr is not the same with primary] nstackmain flag=%d",
+         flag);
+      return NSFW_MEM_ERR;
+    }
+
+  g_shmem_localdata =
+    (nsfw_mem_localdata *) malloc (sizeof (nsfw_mem_localdata));
+
+  if (NULL == g_shmem_localdata)
+    {
+      NSCOMM_LOGERR ("g_shmem_localdata malloc fail");
+      return NSFW_MEM_ERR;
+    }
+
+  iret =
+    MEMSET_S (g_shmem_localdata, sizeof (nsfw_mem_localdata), 0,
+              sizeof (nsfw_mem_localdata));
+  if (EOK != iret)
+    {
+      NSCOMM_LOGERR ("memset fail] g_shmem_localdata=%p ", g_shmem_localdata);
+      free (g_shmem_localdata);
+      g_shmem_localdata = NULL;
+      return NSFW_MEM_ERR;
+    }
+
+  g_shmem_localdata->enflag = para->enflag;
+
+  NSCOMM_LOGINF ("nsfw shmem init end] enflag=%d", para->enflag);
+  return NSFW_MEM_OK;
+
+}
+
+/*
+ *module destroy
+ */
+void
+nsfw_shmem_destroy (void)
+{
+  if (g_shmem_localdata)
+    {
+      free (g_shmem_localdata);
+      g_shmem_localdata = NULL;
+    }
+
+  return;
+}
+
+/*
+ * create a shared memory
+ * nsfw_mem_zone::stname memory name
+ * nsfw_mem_zone::isize
+ */
+mzone_handle
+nsfw_shmem_create (nsfw_mem_zone * pinfo)
+{
+  i8 aname[COMMON_MEM_MEMPOOL_NAMESIZE] = { 0 };
+
+  NSFW_INIT_CHK_RET_NULL ()if (NSFW_PROC_MAIN == NSFW_SHMEM_FLAG)
+    {
+      return common_memzone_data_reserve_name (pinfo->stname.aname,
+                                               pinfo->lenth,
+                                               pinfo->isocket_id);
+    }
+  else
+    {
+      /*app must less than NSFW_MEM_APPNAME_LENTH */
+      NSFW_NAME_LENCHECK_RET_NULL (pinfo->stname.aname, "shmem create")
+        if (-1 ==
+            SPRINTF_S (aname, COMMON_MEM_MEMPOOL_NAMESIZE, "%s_%x",
+                       pinfo->stname.aname, NSFW_SHMEM_PID))
+        {
+          NSCOMM_LOGERR ("SPRINTF_S faild]");
+          return NULL;
+        }
+    }
+
+  return nsfw_memzone_remote_reserv ((char *) &aname[0], pinfo->lenth,
+                                     SOCKET_ID_ANY);
+}
+
+/*
+ *create some memory
+ *inum must be equal iarray_num
+ */
+i32
+nsfw_shmem_createv (nsfw_mem_zone * pmeminfo, i32 inum,
+                    mzone_handle * paddr_array, i32 iarray_num)
+{
+  NSFW_INIT_CHK_RET ();
+
+  if (NSFW_PROC_MASTER == NSFW_SHMEM_FLAG)
+    {
+      return NSFW_MEM_ERR;
+    }
+  else if (NSFW_PROC_MAIN == NSFW_SHMEM_FLAG)
+    {
+      return nsfw_memzone_remote_reserv_v (pmeminfo, paddr_array, iarray_num,
+                                           0);
+    }
+  else
+    {
+      return nsfw_memzone_remote_reserv_v (pmeminfo, paddr_array, iarray_num,
+                                           NSFW_SHMEM_PID);
+    }
+  return NSFW_MEM_ERR;
+}
+
+mzone_handle
+nsfw_shmem_lookup (nsfw_mem_name * pname)
+{
+  i8 aname[COMMON_MEM_MEMPOOL_NAMESIZE] = { 0 };
+  NSFW_INIT_CHK_RET_NULL ();
+
+  if (NSFW_PROC_MAIN == NSFW_SHMEM_FLAG)
+    {
+      return common_memzone_data_lookup_name (pname->aname);
+    }
+
+  if ((NSFW_PROC_NULL == pname->enowner)
+      || (NSFW_PROC_MAIN == pname->enowner))
+    {
+      int retVal =
+        SPRINTF_S (aname, COMMON_MEM_MEMPOOL_NAMESIZE, "%s", pname->aname);
+      if (-1 == retVal)
+        {
+          NSCOMM_LOGERR ("SPRINTF_S faild");
+          return NULL;
+        }
+    }
+  else
+    {
+      /*app must less than NSFW_MEM_APPNAME_LENTH */
+      NSFW_NAME_LENCHECK_RET_NULL (pname->aname, "shmem lookup")
+        int retVal =
+        SPRINTF_S (aname, COMMON_MEM_MEMPOOL_NAMESIZE, "%s_%x", pname->aname,
+                   NSFW_SHMEM_PID);
+      if (-1 == retVal)
+        {
+          NSCOMM_LOGERR ("SPRINTF_S faild");
+          return NULL;
+        }
+    }
+
+  return nsfw_remote_shmem_lookup (aname, NSFW_MEM_MZONE);
+}
+
+i32
+nsfw_shmem_release (nsfw_mem_name * pname)
+{
+  i8 aname[COMMON_MEM_MEMPOOL_NAMESIZE] = { 0 };
+  const struct common_mem_memzone *pmzone = NULL;
+  NSFW_INIT_CHK_RET ();
+
+  if (NSFW_PROC_MAIN == NSFW_SHMEM_FLAG)
+    {
+      pmzone = common_mem_memzone_lookup (pname->aname);
+
+      if (pmzone)
+        {
+          common_mem_memzone_free (pmzone);
+        }
+      return NSFW_MEM_OK;
+    }
+  else
+    {
+      NSFW_NAME_LENCHECK_RET (pname->aname, "shmem free")
+        if (-1 ==
+            SPRINTF_S (aname, COMMON_MEM_MEMPOOL_NAMESIZE, "%s_%x",
+                       pname->aname, NSFW_SHMEM_PID))
+        {
+          NSCOMM_LOGERR ("SPRINTF_S faild");
+          return NSFW_MEM_ERR;
+        }
+    }
+
+  return nsfw_remote_free (aname, NSFW_MEM_MZONE);
+}
+
+mpool_handle
+nsfw_shmem_mbfmpcreate (nsfw_mem_mbfpool * pbufinfo)
+{
+  i8 aname[COMMON_MEM_MEMPOOL_NAMESIZE] = { 0 };
+
+  NSFW_INIT_CHK_RET_NULL ();
+
+  if (NSFW_PROC_MAIN == NSFW_SHMEM_FLAG)
+    {
+      return common_mem_pktmbuf_pool_create (pbufinfo->stname.aname,
+                                             pbufinfo->usnum,
+                                             pbufinfo->uscash_size,
+                                             pbufinfo->uspriv_size,
+                                             pbufinfo->usdata_room,
+                                             pbufinfo->isocket_id);
+    }
+  else
+    {
+      /*app must less than NSFW_MEM_APPNAME_LENTH */
+      NSFW_NAME_LENCHECK_RET_NULL (pbufinfo->stname.aname, "mbufpool create")
+        if (-1 ==
+            SPRINTF_S (aname, COMMON_MEM_MEMPOOL_NAMESIZE, "%s_%x",
+                       pbufinfo->stname.aname, NSFW_SHMEM_PID))
+        {
+          NSCOMM_LOGERR ("SPRINTF_S faild]");
+        }
+    }
+
+  return nsfw_remote_shmem_mbf_create (aname, pbufinfo->usnum,
+                                       pbufinfo->uscash_size,
+                                       pbufinfo->uspriv_size,
+                                       pbufinfo->usdata_room, SOCKET_ID_ANY,
+                                       pbufinfo->enmptype);
+}
+
+/*
+ *create some mbuf pools
+ */
+i32
+nsfw_shmem_mbfmpcreatev (nsfw_mem_mbfpool * pmbfname, i32 inum,
+                         mpool_handle * phandle_array, i32 iarray_num)
+{
+  NSFW_INIT_CHK_RET ();
+
+  if (NSFW_PROC_MASTER == NSFW_SHMEM_FLAG)
+    {
+      return NSFW_MEM_ERR;
+    }
+  else if (NSFW_PROC_MAIN == NSFW_SHMEM_FLAG)
+    {
+      return nsfw_remote_shmem_mbf_createv (pmbfname, phandle_array,
+                                            iarray_num, 0);
+    }
+  else
+    {
+      return nsfw_remote_shmem_mbf_createv (pmbfname, phandle_array,
+                                            iarray_num, NSFW_SHMEM_PID);
+    }
+
+  return NSFW_MEM_ERR;
+}
+
+mbuf_handle
+nsfw_shmem_mbfalloc (mpool_handle mhandle)
+{
+  return (mbuf_handle) common_mem_pktmbuf_alloc ((struct common_mem_mempool *)
+                                                 mhandle);
+}
+
+i32
+nsfw_shmem_mbffree (mbuf_handle mhandle)
+{
+  common_mem_pktmbuf_free ((struct common_mem_mbuf *) mhandle);
+  return NSFW_MEM_OK;
+}
+
+i32
+nsfw_shmem_mbfmprelease (nsfw_mem_name * pname)
+{
+  return NSFW_MEM_OK;
+}
+
+mpool_handle
+nsfw_shmem_mbfmplookup (nsfw_mem_name * pmbfname)
+{
+  i8 aname[COMMON_MEM_MEMPOOL_NAMESIZE] = { 0 };
+
+  NSFW_INIT_CHK_RET_NULL ();
+
+  if (NSFW_PROC_MAIN == NSFW_SHMEM_FLAG)
+    {
+      return common_mem_mempool_lookup (pmbfname->aname);
+    }
+
+  if ((NSFW_PROC_NULL == pmbfname->enowner)
+      || (NSFW_PROC_MAIN == pmbfname->enowner))
+    {
+      if (-1 ==
+          SPRINTF_S (aname, COMMON_MEM_MEMPOOL_NAMESIZE, "%s",
+                     pmbfname->aname))
+        {
+          NSCOMM_LOGERR ("SPRINTF_S faild]");
+        }
+    }
+  else
+    {
+      /*app must less than NSFW_MEM_APPNAME_LENTH */
+      NSFW_NAME_LENCHECK_RET_NULL (pmbfname->aname, "shmem lookup")
+        if (-1 ==
+            SPRINTF_S (aname, COMMON_MEM_MEMPOOL_NAMESIZE, "%s_%x",
+                       pmbfname->aname, NSFW_SHMEM_PID))
+        {
+          NSCOMM_LOGERR ("SPRINTF_S faild]");
+        }
+    }
+
+  return nsfw_remote_shmem_lookup (aname, NSFW_MEM_MBUF);
+}
+
+mring_handle
+nsfw_shmem_spcreate (nsfw_mem_sppool * pmpinfo)
+{
+  i8 aname[COMMON_MEM_MEMPOOL_NAMESIZE] = { 0 };
+
+  NSFW_INIT_CHK_RET_NULL ();
+
+  if (NSFW_PROC_MAIN == NSFW_SHMEM_FLAG)
+    {
+      return nsfw_shmem_pool_create (pmpinfo->stname.aname, pmpinfo->usnum,
+                                     pmpinfo->useltsize, pmpinfo->isocket_id,
+                                     pmpinfo->enmptype);
+    }
+  else
+    {
+      NSFW_NAME_LENCHECK_RET_NULL (pmpinfo->stname.aname, "mpool create")
+        if (-1 ==
+            SPRINTF_S (aname, COMMON_MEM_MEMPOOL_NAMESIZE, "%s_%x",
+                       pmpinfo->stname.aname, NSFW_SHMEM_PID))
+        {
+          NSCOMM_LOGERR ("SPRINTF_S faild]");
+        }
+    }
+
+  return nsfw_remote_shmem_mpcreate (aname, pmpinfo->usnum,
+                                     pmpinfo->useltsize, SOCKET_ID_ANY,
+                                     pmpinfo->enmptype);
+}
+
+i32
+nsfw_shmem_spcreatev (nsfw_mem_sppool * pmpinfo, i32 inum,
+                      mring_handle * pringhandle_array, i32 iarray_num)
+{
+  NSFW_INIT_CHK_RET ();
+
+  if (NSFW_PROC_MASTER == NSFW_SHMEM_FLAG)
+    {
+      return NSFW_MEM_ERR;
+    }
+  else if (NSFW_PROC_MAIN == NSFW_SHMEM_FLAG)
+    {
+      return nsfw_remote_shmem_mpcreatev (pmpinfo, pringhandle_array, inum,
+                                          0);
+    }
+  else
+    {
+      return nsfw_remote_shmem_mpcreatev (pmpinfo, pringhandle_array, inum,
+                                          NSFW_SHMEM_PID);
+    }
+  return NSFW_MEM_ERR;
+}
+
+i32
+nsfw_lshmem_ringcreatev (const char *name, i32 ieltnum,
+                         mring_handle * pringhandle_array, i32 iringnum,
+                         i32 socket_id, nsfw_mpool_type entype)
+{
+  i32 useltsize = 0;
+  mring_handle nhandle = NULL;
+  i32 icount = 0;
+  i32 n = 0;
+  uint64_t baseaddr = 0;
+  uint64_t endaddr = 0;
+  i32 usnum = common_mem_align32pow2 (ieltnum + 1);
+
+  useltsize =
+    sizeof (struct nsfw_mem_ring) + usnum * sizeof (union RingData_U);
+  nhandle =
+    nsfw_shmem_pool_create (name, iringnum, useltsize, socket_id,
+                            NSFW_MRING_SPSC);
+  if (NULL == (nhandle))
+    {
+      return NSFW_MEM_ERR;
+    }
+
+  n =
+    nsfw_shmem_ring_sc_dequeuev (nhandle, (void **) pringhandle_array,
+                                 iringnum);
+
+  if (n != iringnum)
+    {
+      NSCOMM_LOGERR
+        ("ring dequeuev failed] ring=%p, dequeue num=%d, expect num=%d",
+         nhandle, n, iringnum);
+      return NSFW_MEM_ERR;
+    }
+
+  nsfw_shmem_ring_baseaddr_query (&baseaddr, &endaddr);
+
+  for (icount = 0; icount < iringnum; icount++)
+    {
+      nsfw_mem_ring_init (pringhandle_array[icount], usnum, (void *) baseaddr,
+                          NSFW_SHMEM, entype);
+    }
+
+  return NSFW_MEM_OK;
+}
+
+i32
+nswf_shmem_sp_ringcreate (nsfw_mem_mring * prpoolinfo,
+                          mring_handle * pringhandle_array, i32 iringnum)
+{
+  i8 aname[COMMON_MEM_MEMPOOL_NAMESIZE] = { 0 };
+
+  NSFW_INIT_CHK_RET ();
+
+  if (NSFW_PROC_MAIN == NSFW_SHMEM_FLAG)
+    {
+      return nsfw_lshmem_ringcreatev (prpoolinfo->stname.aname,
+                                      prpoolinfo->usnum, pringhandle_array,
+                                      iringnum, SOCKET_ID_ANY,
+                                      prpoolinfo->enmptype);
+    }
+  else
+    {
+      NSFW_NAME_LENCHECK_RET (prpoolinfo->stname.aname, "ring pool")
+        int retVal = SPRINTF_S (aname, COMMON_MEM_MEMPOOL_NAMESIZE, "%s_%x",
+                                prpoolinfo->stname.aname, NSFW_SHMEM_PID);
+      if (-1 == retVal)
+        {
+          NSCOMM_LOGERR ("SPRINTF_S faild]");
+        }
+    }
+
+  return nsfw_remote_shmem_ringcreatev (aname, prpoolinfo->usnum,
+                                        pringhandle_array, iringnum,
+                                        SOCKET_ID_ANY, prpoolinfo->enmptype);
+}
+
+i32
+nsfw_shmem_sprelease (nsfw_mem_name * pname)
+{
+  i8 aname[COMMON_MEM_MEMPOOL_NAMESIZE] = { 0 };
+  void *mz_mem = NULL;
+  struct nsfw_mem_ring *ring_ptr = NULL;
+  NSFW_INIT_CHK_RET ();
+
+  if (NSFW_PROC_MAIN == NSFW_SHMEM_FLAG)
+    {
+      mz_mem = common_memzone_data_lookup_name (pname->aname);
+
+      if (mz_mem)
+        {
+          ring_ptr =
+            (struct nsfw_mem_ring *) ((char *) mz_mem +
+                                      sizeof (struct nsfw_shmem_ring_head));
+          nsfw_shmem_pool_free (ring_ptr);
+        }
+      return NSFW_MEM_OK;
+    }
+  else
+    {
+      NSFW_NAME_LENCHECK_RET (pname->aname, "shmem free")
+        if (-1 ==
+            SPRINTF_S (aname, COMMON_MEM_MEMPOOL_NAMESIZE, "%s_%x",
+                       pname->aname, NSFW_SHMEM_PID))
+        {
+          NSCOMM_LOGERR ("SPRINTF_S faild]");
+        }
+    }
+
+  return nsfw_remote_free (aname, NSFW_MEM_SPOOL);
+}
+
+mring_handle
+nsfw_shmem_sp_lookup (nsfw_mem_name * pname)
+{
+  i8 aname[COMMON_MEM_MEMPOOL_NAMESIZE] = { 0 };
+  void *mz_mem = NULL;
+  struct nsfw_mem_ring *ring_ptr = NULL;
+  NSFW_INIT_CHK_RET_NULL ();
+
+  if (NSFW_PROC_MAIN == NSFW_SHMEM_FLAG)
+    {
+      mz_mem = common_memzone_data_lookup_name (pname->aname);
+
+      if (mz_mem)
+        {
+          ring_ptr =
+            (struct nsfw_mem_ring *) ((char *) mz_mem +
+                                      sizeof (struct nsfw_shmem_ring_head));
+          return ring_ptr;
+        }
+      return mz_mem;
+    }
+
+  if ((NSFW_PROC_NULL == pname->enowner)
+      || (NSFW_PROC_MAIN == pname->enowner))
+    {
+      if (-1 ==
+          SPRINTF_S (aname, COMMON_MEM_MEMPOOL_NAMESIZE, "%s", pname->aname))
+        {
+          NSCOMM_LOGERR ("SPRINTF_S faild]");
+        }
+    }
+  else
+    {
+      /*app's name can not over NSFW_MEM_APPNAME_LENTH */
+      NSFW_NAME_LENCHECK_RET_NULL (pname->aname, "shmem lookup")
+        if (-1 ==
+            SPRINTF_S (aname, COMMON_MEM_MEMPOOL_NAMESIZE, "%s_%x",
+                       pname->aname, NSFW_SHMEM_PID))
+        {
+          NSCOMM_LOGERR ("SPRINTF_S faild]");
+        }
+    }
+
+  return nsfw_remote_shmem_lookup (aname, NSFW_MEM_SPOOL);
+}
+
+mring_handle
+nsfw_shmem_ringcreate (nsfw_mem_mring * pringinfo)
+{
+  i8 aname[COMMON_MEM_MEMPOOL_NAMESIZE] = { 0 };
+
+  NSFW_INIT_CHK_RET_NULL ();
+
+  if (NSFW_PROC_MAIN == NSFW_SHMEM_FLAG)
+    {
+      return nsfw_shmem_ring_create (pringinfo->stname.aname,
+                                     pringinfo->usnum, pringinfo->isocket_id,
+                                     pringinfo->enmptype);
+    }
+  else
+    {
+      NSFW_NAME_LENCHECK_RET_NULL (pringinfo->stname.aname, "ring create")
+        if (-1 ==
+            SPRINTF_S (aname, COMMON_MEM_MEMPOOL_NAMESIZE, "%s_%x",
+                       pringinfo->stname.aname, NSFW_SHMEM_PID))
+        {
+          NSCOMM_LOGERR ("SPRINTF_S faild]");
+        }
+    }
+
+  return nsfw_remote_shmem_ringcreate (aname, pringinfo->usnum, SOCKET_ID_ANY,
+                                       pringinfo->enmptype);
+}
+
+mring_handle
+nsfw_shmem_ring_lookup (nsfw_mem_name * pname)
+{
+  return nsfw_shmem_lookup (pname);
+}
+
+i32
+nsfw_shmem_ringrelease (nsfw_mem_name * pname)
+{
+  return nsfw_shmem_release (pname);
+}
+
+size_t
+nsfw_shmem_mbufpool_statics (mpool_handle mbufpool)
+{
+  struct common_mem_mempool *mp = (struct common_mem_mempool *) mbufpool;
+  return (size_t) mp->size * (mp->header_size + mp->elt_size +
+                              mp->trailer_size) +
+    (size_t) mp->private_data_size +
+    (size_t)
+    common_mem_ring_get_memsize (common_mem_align32pow2 (mp->size + 1));
+}
+
+size_t
+nsfw_shmem_sppool_statics (mring_handle sppool)
+{
+  struct nsfw_shmem_ring_head *temp = NULL;
+  size_t lent = 0;
+  temp =
+    (struct nsfw_shmem_ring_head *) ((char *) sppool -
+                                     sizeof (struct nsfw_shmem_ring_head));
+
+  while (temp)
+    {
+      lent += temp->mem_zone->len;
+      temp = temp->next;
+    }
+
+  return lent;
+}
+
+size_t
+nsfw_shmem_ring_statics (mring_handle handle)
+{
+  struct nsfw_mem_ring *ring = (struct nsfw_mem_ring *) handle;
+  return ring->size * sizeof (union RingData_U) +
+    sizeof (struct nsfw_mem_ring);
+}
+
+ssize_t
+nsfw_shmem_stactic (void *handle, nsfw_mem_struct_type type)
+{
+  switch (type)
+    {
+    case NSFW_MEM_MBUF:
+      return nsfw_shmem_mbufpool_statics (handle);
+    case NSFW_MEM_SPOOL:
+      return nsfw_shmem_sppool_statics (handle);
+    case NSFW_MEM_RING:
+      return nsfw_shmem_ring_statics (handle);
+    default:
+      break;
+    }
+  return -1;
+}
+
+i32
+nsfw_shmem_mbuf_recycle (mpool_handle handle)
+{
+#if 0
+  const struct common_mem_mempool *mp = (struct common_mem_mempool *) handle;
+  struct common_mem_ring *rteRing = NULL;
+  struct common_mem_mbuf *m_buf = NULL;
+  uint32_t item;
+  u32_t *recycle_flg;
+  uint32_t size = mp->size;
+  uint32_t threadsize = (size >> 2) * 3;
+  rteRing = (struct common_mem_ring *) ADDR_SHTOL (mp->ring);
+
+  if (rteRing->prod.tail - rteRing->cons.head < threadsize)
+    {
+      for (item = 0; item < size - 1; item++)
+        {
+          m_buf = (struct common_mem_mbuf *) ADDR_SHTOL (mp->elt_va_start + item * (mp->header_size + mp->elt_size + mp->trailer_size) + mp->header_size);      /*lint !e647 */
+          recycle_flg =
+            (uint32_t *) ((char *) (ADDR_SHTOL (m_buf->buf_addr_align)) +
+                          RTE_PKTMBUF_HEADROOM - sizeof (uint32_t));
+
+          if (m_buf->refcnt > 0 && *recycle_flg == MBUF_HLD_BY_APP)
+            {
+              NSCOMM_LOGINF ("free mbuf hold by app]ring=%p, mbuf=%p", handle,
+                             m_buf);
+              *recycle_flg = MBUF_UNUSED;
+              common_mem_pktmbuf_free (m_buf);
+            }
+        }
+    }
+
+  NSCOMM_LOGINF ("To recycle app_tx_pool now]ring=%p,prod.head=%u,"
+                 "prod.tail=%u,cons.head=%u,cons.tail=%u.", handle,
+                 rteRing->prod.head, rteRing->prod.tail,
+                 rteRing->cons.head, rteRing->cons.tail);
+
+  /*we Must check and recorrect the Queue if Queue is not correct
+     1.if proc.head != proc.tail  set proc.head to proc.tail [may lost some buf,but the queue still can use]
+     App May not putIn Data , just done head++, we can't set proc.tail to proc.head.
+     2.if cons.head != cons.tail set cons.tail to cons.head [may lost some buf,but the queue still can use]
+     App May alread finish deque,just not tail++, we can't set cons.head to cons.tail.
+   */
+  if ((rteRing->prod.head != rteRing->prod.tail)
+      || (rteRing->cons.head != rteRing->cons.tail))
+    {
+      rteRing->prod.head = rteRing->prod.tail;
+      rteRing->cons.tail = rteRing->cons.head;
+    }
+#endif
+  return NSFW_MEM_OK;
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_shmem_sp_iterator
+*   Description  : sp pool iterator
+*   Input        : mpool_handle handle
+*                  u32 start
+*                  u32 end
+*                  nsfw_mem_item_fun fun
+*                  void *argv
+*   Output       : None
+*   Return Value : i32
+*   Calls        :
+*   Called By    :
+*****************************************************************************/
+i32
+nsfw_shmem_sp_iterator (mpool_handle handle, u32 start, u32 end,
+                        nsfw_mem_item_fun fun, void *argv)
+{
+  struct nsfw_mem_ring *perfring_ptr = (struct nsfw_mem_ring *) handle;
+  if (NULL == perfring_ptr || NULL == fun)
+    {
+      return 0;
+    }
+
+  if (0 == perfring_ptr->eltsize)
+    {
+      return 0;
+    }
+
+  int num = perfring_ptr->size;
+  if (start >= (u32) num || end <= start)
+    {
+      return 0;
+    }
+
+  struct nsfw_shmem_ring_head *ring_head =
+    (struct nsfw_shmem_ring_head *) ((char *) handle -
+                                     sizeof (struct nsfw_shmem_ring_head));
+  void *mz =
+    (void *) ((char *) perfring_ptr + sizeof (struct nsfw_mem_ring) +
+              num * sizeof (union RingData_U));
+
+  if (ring_head->mem_zone->len <
+      sizeof (struct nsfw_shmem_ring_head) + sizeof (struct nsfw_mem_ring) +
+      num * sizeof (union RingData_U))
+    {
+      return 0;
+    }
+
+  u32 mz_len =
+    ring_head->mem_zone->len - sizeof (struct nsfw_shmem_ring_head) -
+    sizeof (struct nsfw_mem_ring) - num * sizeof (union RingData_U);
+
+  u32 start_idx = 0;
+  u32 elm_num = 0;
+  elm_num = mz_len / perfring_ptr->eltsize;
+  while (start > start_idx + elm_num)
+    {
+      if (NULL == ring_head->next || NULL == ring_head->next->mem_zone
+          || 0 == elm_num)
+        {
+          return 0;
+        }
+
+      ring_head =
+        (struct nsfw_shmem_ring_head *) ring_head->next->mem_zone->addr_64;
+      mz_len =
+        ring_head->mem_zone->len - sizeof (struct nsfw_shmem_ring_head);
+
+      elm_num = mz_len / perfring_ptr->eltsize;
+      mz =
+        (void *) ((char *) ring_head + sizeof (struct nsfw_shmem_ring_head));
+      start_idx += elm_num;
+    }
+
+  u32 cur_idx = start - start_idx;
+  char *cur_elm = NULL;
+  int proc_count = 0;
+  while (cur_idx + start_idx < end && cur_idx + start_idx < (u32) num)
+    {
+      if (cur_idx >= elm_num)
+        {
+          if (NULL == ring_head->next || NULL == ring_head->next->mem_zone
+              || 0 == elm_num)
+            {
+              break;
+            }
+
+          ring_head =
+            (struct nsfw_shmem_ring_head *) ring_head->next->
+            mem_zone->addr_64;
+          mz_len =
+            ring_head->mem_zone->len - sizeof (struct nsfw_shmem_ring_head);
+
+          elm_num = mz_len / perfring_ptr->eltsize;
+          mz =
+            (void *) ((char *) ring_head +
+                      sizeof (struct nsfw_shmem_ring_head));
+          start_idx += elm_num;
+
+          cur_idx = 0;
+          cur_elm = NULL;
+          continue;
+        }
+
+      if (NULL == cur_elm)
+        {
+          cur_elm = ((char *) mz + cur_idx * perfring_ptr->eltsize);
+        }
+      else
+        {
+          cur_elm += perfring_ptr->eltsize;
+        }
+
+      cur_idx++;
+      proc_count++;
+      (void) fun (cur_elm, argv);
+    }
+
+  return proc_count;
+}
+
+i32
+nsfw_shmem_mbuf_iterator (mpool_handle handle, u32 start, u32 end,
+                          nsfw_mem_item_fun fun, void *argv)
+{
+  return dmm_pktmbuf_pool_iterator ((struct common_mem_mempool *) handle,
+                                    start, end, (dmm_mbuf_item_fun) fun,
+                                    argv);
+}