dmm initial commit

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

22 files changed, 6265 insertions, 0 deletions

diff --git a/src/framework/common/mem_mgr/include/nsfw_mem_desc.h b/src/framework/common/mem_mgr/include/nsfw_mem_desc.h
new file mode 100644
index 0000000..1e959d9
--- /dev/null
+++ b/src/framework/common/mem_mgr/include/nsfw_mem_desc.h
@@ -0,0 +1,172 @@
+/*
+*
+* 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.
+*/
+
+#ifndef _NSFW_MEM_DESC_H
+#define _NSFW_MEM_DESC_H
+#include <sys/types.h>
+#include <unistd.h>
+#include <string.h>
+#include "nsfw_mem_api.h"
+#include "nsfw_mgr_com_api.h"
+#include "nsfw_ring_data.h"
+
+#define NSFW_MEM_NOT_INIT  (0)
+#define NSFW_MEM_INIT_ERR  (1)
+#define NSFW_MEM_INIT_OK   (2)
+
+#define NSFW_NAME_LENCHECK_RET(name, desc) \
+    { \
+        i32 inamelen = strlen(name); \
+        if (inamelen >= NSFW_MEM_APPNAME_LENTH) \
+        { \
+            NSCOMM_LOGERR("name length check fail] desc=%s, name len=%d, expected max=%d", \
+                         #desc, inamelen, NSFW_MEM_APPNAME_LENTH); \
+            return NSFW_MEM_ERR; \
+        } \
+    }
+
+#define NSFW_NAME_LENCHECK_RET_NULL(name, desc) \
+    { \
+        i32 inamelen = strlen(name); \
+        if (inamelen >= NSFW_MEM_APPNAME_LENTH) \
+        { \
+            NSCOMM_LOGERR("name length check fail] desc=%s, name len=%d, expected max=%d", \
+                         #desc, inamelen, NSFW_MEM_APPNAME_LENTH); \
+            return NULL; \
+        } \
+    }
+
+#define NSFW_MEM_PARA_CHECK_RET(handle, pdata, desc, num)  {\
+        if ((NULL == (handle)) || (NULL == (pdata)) || (num <= 0)\
+            || (((struct  nsfw_mem_ring*)(handle))->memtype >= NSFW_MEM_TYPEMAX)) \
+        {   \
+            NSCOMM_LOGERR("input para error] desc=%s,mhandle=%p, pdata=%p, inum=%d", desc, (handle), (pdata), num); \
+            return 0;  \
+        }  \
+    }
+
+#define NSFW_MEM_ENQ_PARA_CHECK_RET(handle, desc)  {\
+        if ((NULL == (handle)) \
+            || (((struct  nsfw_mem_ring*)(handle))->memtype >= NSFW_MEM_TYPEMAX)) \
+        {   \
+            NSCOMM_LOGERR("input para error] desc=%s,mhandle=%p", desc, (handle)); \
+            return 0;  \
+        }  \
+    }
+
+#define NSFW_MEM_NAME_CHECK_RET_ERR(pname, desc)  {\
+        if ((NULL == (pname)) || ((pname)->entype >= NSFW_MEM_TYPEMAX)) \
+        { \
+            NSCOMM_LOGERR("input para error] desc=%s, pname=%p, mtype=%d", desc, pname, (pname) ? (pname)->entype:-1); \
+            return NSFW_MEM_ERR;  \
+        }  \
+    }
+
+#define NSFW_MEM_NAME_CHECK_RET_NULL(pname, desc)  {\
+        if ((NULL == (pname)) || ((pname)->entype >= NSFW_MEM_TYPEMAX)) \
+        { \
+            NSCOMM_LOGERR("input para error] desc=%s, pname=%p, mtype=%d", desc, pname, (pname) ? (pname)->entype:-1); \
+            return NULL;  \
+        }  \
+    }
+
+#define NSFW_MEM_RING_CHECK_RET(pringinfo, pringhandle_array, iringnum)  {\
+        if ((NULL == pringinfo) || (NULL == pringhandle_array) || (pringinfo[0].stname.entype >= NSFW_MEM_TYPEMAX)) \
+        {  \
+            NSCOMM_LOGERR("input para error] pringinfo=%p, iringnum=%d, pringhandle_array=%p, mtype=%d",  \
+                         pringinfo, iringnum, pringhandle_array, pringinfo ? pringinfo[0].stname.entype : (-1));  \
+            return NSFW_MEM_ERR;  \
+        }  \
+    }
+
+#define NSFW_MEM_RINGV_CHECK_RET(pmpinfo, inum, pringhandle_array, iarray_num)  { \
+        if ((NULL == pmpinfo) || (NULL == pringhandle_array)  \
+            || (inum != iarray_num) || (inum <= 0) || (pmpinfo[0].stname.entype >= NSFW_MEM_TYPEMAX)) \
+        {   \
+            NSCOMM_LOGERR("input para error] pmpinfo=%p, inum=%d, pringhandle_array=%p, iarray_num=%d", \
+                         pmpinfo, inum, pringhandle_array, iarray_num, pmpinfo ? pmpinfo[0].stname.entype : (-1));  \
+            return NSFW_MEM_ERR;  \
+        }  \
+    }
+
+#define NSFW_MEM_MBUF_CHECK_RET_ERR(mhandle, entype, desc)  {\
+        if ((NULL == mhandle) || (entype >= NSFW_MEM_TYPEMAX)) \
+        { \
+            NSCOMM_LOGERR("input para error] desc=%s, mhandle=%p, mtype=%d", desc, mhandle, entype); \
+            return NSFW_MEM_ERR; \
+        } \
+    }
+
+#define NSFW_MEM_MBUF_CHECK_RET_NULL(mhandle, entype, desc)  {\
+        if ((NULL == mhandle) || (entype >= NSFW_MEM_TYPEMAX)) \
+        { \
+            NSCOMM_LOGERR("input para error] desc=%s, mhandle=%p, mtype=%d", desc, mhandle, entype); \
+            return NULL; \
+        } \
+    }
+
+/*memory access inferface define*/
+typedef struct
+{
+  i32 (*mem_ops_init) (nsfw_mem_para * para);
+  void (*mem_ops_destroy) (void);
+    mzone_handle (*mem_ops_zone_creae) (nsfw_mem_zone * pinfo);
+    i32 (*mem_ops_zone_createv) (nsfw_mem_zone * pmeminfo, i32 inum,
+                                 mzone_handle * paddr_array, i32 iarray_num);
+    mzone_handle (*mem_ops_zone_lookup) (nsfw_mem_name * pname);
+    i32 (*mem_ops_mzone_release) (nsfw_mem_name * pname);
+    mpool_handle (*mem_ops_mbfmp_create) (nsfw_mem_mbfpool * pbufinfo);
+    i32 (*mem_ops_mbfmp_createv) (nsfw_mem_mbfpool * pmbfname, i32 inum,
+                                  mpool_handle * phandle_array,
+                                  i32 iarray_num);
+    mbuf_handle (*mem_ops_mbf_alloc) (mpool_handle mhandle);
+    i32 (*mem_ops_mbf_free) (mbuf_handle mhandle);
+    mpool_handle (*mem_ops_mbfmp_lookup) (nsfw_mem_name * pmbfname);
+    i32 (*mem_ops_mbfmp_release) (nsfw_mem_name * pname);
+    mring_handle (*mem_ops_sp_create) (nsfw_mem_sppool * pmpinfo);
+    i32 (*mem_ops_sp_createv) (nsfw_mem_sppool * pmpinfo, i32 inum,
+                               mring_handle * pringhandle_array,
+                               i32 iarray_num);
+    i32 (*mem_ops_spring_create) (nsfw_mem_mring * prpoolinfo,
+                                  mring_handle * pringhandle_array,
+                                  i32 iringnum);
+    i32 (*mem_ops_sp_release) (nsfw_mem_name * pname);
+    mring_handle (*mem_ops_sp_lookup) (nsfw_mem_name * pname);
+    mring_handle (*mem_ops_ring_create) (nsfw_mem_mring * pringinfo);
+    mring_handle (*mem_ops_ring_lookup) (nsfw_mem_name * pname);
+    i32 (*mem_ops_ring_release) (nsfw_mem_name * pname);
+    ssize_t (*mem_ops_mem_statics) (void *handle, nsfw_mem_struct_type type);
+    i32 (*mem_ops_mbuf_recycle) (mpool_handle handle);
+    i32 (*mem_ops_sp_iterator) (mpool_handle handle, u32 start, u32 end,
+                                nsfw_mem_item_fun fun, void *argv);
+    i32 (*mem_ops_mbuf_iterator) (mpool_handle handle, u32 start, u32 end,
+                                  nsfw_mem_item_fun fun, void *argv);
+} nsfw_mem_ops;
+
+typedef struct
+{
+  nsfw_mem_type entype;
+  nsfw_mem_ops *stmemop;
+} nsfw_mem_attr;
+
+typedef struct
+{
+  fw_poc_type enflag;           /*app, nStackMain, Master */
+} nsfw_mem_localdata;
+
+extern nsfw_mem_attr g_nsfw_mem_ops[];
+extern i32 g_mem_type_num;
+#endif
diff --git a/src/framework/common/mem_mgr/include/nsfw_ring_data.h b/src/framework/common/mem_mgr/include/nsfw_ring_data.h
new file mode 100644
index 0000000..99ec0ed
--- /dev/null
+++ b/src/framework/common/mem_mgr/include/nsfw_ring_data.h
@@ -0,0 +1,95 @@
+/*
+*
+* 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.
+*/
+
+#ifndef _NSFW_RING_DATA_H_
+#define _NSFW_RING_DATA_H_
+
+#include <stdint.h>
+#include "types.h"
+#include "common_mem_api.h"
+
+#define VALUE_LEN 40
+
+/*
+Ring Data has two part; Ver&Data
+val is a pointer offset base on rte_perf_ring::Addrbase, this struct support 1TB, it's enough now;
+future __int128 maybe used, this type can perfectly solve the version & address rang problem.
+*/
+union RingData_U
+{
+  struct RingData_S
+  {
+    /*
+       value of data, indeed it's a pointer offset base on rte_perf_ring::Addrbase;40bit is enough for user space addr
+       ver must using 24bit, so val using 40bit; a CAS  now just support 64bit; in future, we may using __int128,now __int128 not support well.
+     */
+    volatile unsigned long long val:VALUE_LEN;
+    /*
+       version of data,  using 16b store version flg is more suitable for Address save, but using 16b version is too short, it's value range is [0-65535];
+       between two cpu schedule time (TM-SPACE) of one process/thread, other processes/threads do N times queue oper. if N > 65535, still have a chance of ABA.
+       if using a 24bit  save version flg, if ABA happened, 16777216 times queue oper need done in one TM-SPACE, it's impossible for today cpu.
+     */
+    volatile unsigned long long ver:(64 - VALUE_LEN);
+  } data_s;
+  u64 data_l;
+};
+
+/*
+   this high perf Ring rely on the init value of Ring Slot;
+   Ring Must init using PerfRingInit, Pool Must init using PerfPoolInit
+
+   the addrbase is base addr for all element; now we support 1024G offset;
+   for nstack the Ring element is from hugepage, and the addr is in stack space.
+
+   1. not support a ring who's element space range bigger than 1024GB
+      [if one element from heep, one from stack, range will bigger than 1024GB, we not support]
+   2. one more thing addr from mmap is in stack
+   3. rte_perf_ring must create by rte_perf_ring_create/rte_perf_pool_create
+*/
+struct nsfw_mem_ring
+{
+  u8 memtype;                   //shared, no shared
+  u8 ringflag;                  //scmp, scsp, mcsp,mcmp
+  u16 reserv;                   //reserv data
+  u32 size;                     //size of the Ring, must 2^n
+  u32 eltsize;                  //for sppool, it is the size of per buf, if is ring, eltsize is zero.
+  u32 mask;                     //mask of the Ring,  used mask mod Head/Tail to get real pos, must 2^n-1
+  void *Addrbase;               /*Cause the Addr we support just 40b(1024G),  we using a basAddr+offset to get the real addr; ring[x].data_s.val just store offset;
+                                 * not used when no shared mode
+                                 */
+  volatile u32_t prodhflag;     //for nshmem fork recover
+  volatile u32_t prodtflag;     //for nshmem fork recover
+  volatile u32_t conshflag;     //for nshmem fork recover
+  volatile u32_t constflag;     //for nshmem fork recover
+  nsfw_res res_chk;
+
+  struct
+  {
+    volatile u32 head;          //Head of the Ring, used to indicat pos where to pull a val
+    volatile u32 tail;          //for nshmem, shmem not used.
+  } prod;
+  struct
+  {
+    volatile u32 head;          //for nshmem, shmem not used.
+    volatile u32 tail;          //Tail of the Ring, used to indicat pos where to push a val
+  } cons;
+  u32 uireserv[4];              //reserved for update
+  union RingData_U ring[0];     //Value of Ring
+};
+
+#define PERFRING_ADDR_RANGE  (0xFFFFFFFFFFL)
+
+#endif /*_NSFW_RING_DATA_H_*/
diff --git a/src/framework/common/mem_mgr/include/nsfw_ring_fun.h b/src/framework/common/mem_mgr/include/nsfw_ring_fun.h
new file mode 100644
index 0000000..57a7bf3
--- /dev/null
+++ b/src/framework/common/mem_mgr/include/nsfw_ring_fun.h
@@ -0,0 +1,110 @@
+/*
+*
+* 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.
+*/
+
+#ifndef _NSFW_RING_FUN_H_
+#define _NSFW_RING_FUN_H_
+
+#include <stdint.h>
+#include "common_pal_bitwide_adjust.h"
+#include "nsfw_mem_api.h"
+#include "nsfw_ring_data.h"
+
+/*
+   for nstack I advise addrbase set to lowest of mmaped hugepage Addr.
+   to simple:
+   1. ring element is from mmaped mem, set Addrbase to 0x7fffffffffff - 0xffffffffff is OK;
+   1. ring element is from heap, set Addrbase to NULL is ok;
+*/
+static inline void
+nsfw_mem_ring_init (struct nsfw_mem_ring *ring, unsigned int size,
+                    void *addrbase, unsigned char memtype, unsigned char flag)
+{
+  unsigned int loop = 0;
+
+  if (!ring)
+    {
+      return;
+    }
+
+  ring->prod.head = 0;
+  ring->prod.tail = 0;
+  ring->cons.head = 0;
+  ring->cons.tail = 0;
+  ring->size = size;
+  ring->eltsize = 0;
+  ring->mask = size - 1;
+  ring->memtype = memtype;
+  ring->ringflag = flag;
+  ring->prodtflag = ring->prodhflag = get_sys_pid ();
+  ring->conshflag = ring->constflag = get_sys_pid ();
+  /*if shmem, addrbase already changed to primary memory address */
+  ring->Addrbase = addrbase;
+  ring->uireserv[0] = 0;
+  ring->uireserv[1] = 0;
+  ring->uireserv[2] = 0;
+  ring->uireserv[3] = 0;
+
+  /*init Ring */
+  for (loop = 0; loop < size; loop++)
+    {
+      /*
+         for a empty ring, version is the mapping head val - size
+         so the empty ring's ver is loop-size;
+       */
+      ring->ring[loop].data_s.ver = (loop - size);
+      ring->ring[loop].data_s.val = 0;
+    }
+}
+
+/*
+another way to init Pool while no continuous space
+1. init a empt rte_perf_ring
+2. add element to PerRing.
+*/
+static inline void
+nsfw_mem_pool_head_init (struct nsfw_mem_ring *ring, unsigned int size,
+                         unsigned int eltsize, void *addrbase,
+                         nsfw_mem_type memtype, nsfw_mpool_type flag)
+{
+  ring->prod.head = size;
+  ring->prod.tail = size;
+  ring->cons.head = 0;
+  ring->cons.tail = 0;
+  ring->size = size;
+  ring->eltsize = eltsize;
+  ring->mask = size - 1;
+  ring->memtype = memtype;
+  ring->ringflag = flag;
+  ring->prodtflag = ring->prodhflag = get_sys_pid ();
+  ring->conshflag = ring->constflag = get_sys_pid ();
+  /*if shmem, addrbase already changed to primary memory address */
+  ring->Addrbase = addrbase;
+  ring->uireserv[0] = 0;
+  ring->uireserv[1] = 0;
+  ring->uireserv[2] = 0;
+  ring->uireserv[3] = 0;
+  return;
+}
+
+#define NSFW_RING_FLAG_CHECK_RET(handle, desc) {\
+        if (((struct  nsfw_mem_ring*)mhandle)->ringflag >= NSFW_MPOOL_TYPEMAX) \
+        { \
+            NSCOMM_LOGERR("invalid ring] desc=%s, ringflag=%d", desc, ((struct  nsfw_mem_ring*)mhandle)->ringflag); \
+            return 0; \
+        } \
+    }
+
+#endif /*_NSFW_RING_FUN_H_*/
diff --git a/src/framework/common/mem_mgr/nsfw_mem_api.c b/src/framework/common/mem_mgr/nsfw_mem_api.c
new file mode 100644
index 0000000..b795921
--- /dev/null
+++ b/src/framework/common/mem_mgr/nsfw_mem_api.c
@@ -0,0 +1,879 @@
+/*
+*
+* 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 <sys/types.h>
+#include <unistd.h>
+#include "nsfw_mem_desc.h"
+#include "nstack_securec.h"
+
+#ifdef SYS_MEM_RES_STAT
+#include "common_mem_ring.h"
+#include "common_mem_mempool.h"
+#endif
+
+#define MEM_OP_CALL_OK_RET(mtype, fun, para) { \
+        if (g_nsfw_mem_ops[mtype].stmemop->fun) \
+        { \
+            return g_nsfw_mem_ops[mtype].stmemop->fun para; \
+        } \
+    }
+
+/*****************************************************************************
+*   Prototype    : nsfw_mem_init
+*   Description  : memory mgr module init
+*   Input        : point to nstak_fwmem_para
+*   Output       : None
+*   Return Value : i32
+*   Calls        :
+*   Called By    :
+*
+*****************************************************************************/
+i32
+nsfw_mem_init (void *para)
+{
+  nsfw_mem_para *ptempara = NULL;
+  i32 iret = NSFW_MEM_OK;
+  i32 icount = 0;
+  i32 iindex = 0;
+
+  if (NULL == para)
+    {
+      NSCOMM_LOGERR ("ns mem init input error");
+      return NSFW_MEM_ERR;
+    }
+
+  ptempara = (nsfw_mem_para *) para;
+
+  if (ptempara->enflag >= NSFW_PROC_MAX)
+    {
+      NSCOMM_LOGERR ("ns mem init input enflag invalid] enflag=%d",
+                     ptempara->enflag);
+      return NSFW_MEM_ERR;
+    }
+
+  NSCOMM_LOGINF ("ns mem init begin] enflag=%d, iargsnum=%d",
+                 ptempara->enflag, ptempara->iargsnum);
+
+  for (iindex = 0; iindex < ptempara->iargsnum; iindex++)
+    {
+      NSCOMM_LOGINF ("%s", ptempara->pargs[iindex]);
+    }
+
+  for (icount = 0; icount < g_mem_type_num; icount++)
+    {
+      if ((NULL != g_nsfw_mem_ops[icount].stmemop)
+          && (NULL != g_nsfw_mem_ops[icount].stmemop->mem_ops_init))
+        {
+          iret = g_nsfw_mem_ops[icount].stmemop->mem_ops_init (ptempara);
+
+          if (NSFW_MEM_OK != iret)
+            {
+              NSCOMM_LOGERR ("mem init failed]index=%d, memtype=%d", icount,
+                             g_nsfw_mem_ops[icount].entype);
+              break;
+            }
+        }
+    }
+
+  /*if some module init fail, destory the moudles that success */
+  if (icount < g_mem_type_num)
+    {
+      for (iindex = 0; iindex < icount; iindex++)
+        {
+          if (g_nsfw_mem_ops[icount].stmemop->mem_ops_destroy)
+            {
+              g_nsfw_mem_ops[icount].stmemop->mem_ops_destroy ();
+            }
+        }
+
+      return NSFW_MEM_ERR;
+    }
+
+  NSCOMM_LOGINF ("ns mem init end");
+  return NSFW_MEM_OK;
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_mem_zone_create
+*   Description  : create a block memory with name
+*                  nsfw_mem_zone::stname
+*                  nsfw_mem_zone::isize
+*   note         : 1. the lenth of name must be less than NSFW_MEM_APPNAME_LENTH.
+*   Input        : nsfw_mem_zone* pinfo
+*   Output       : None
+*   Return Value : mzone_handle
+*   Calls        :
+*   Called By    :
+*
+*****************************************************************************/
+mzone_handle
+nsfw_mem_zone_create (nsfw_mem_zone * pinfo)
+{
+
+  if ((NULL == pinfo) || (pinfo->stname.entype >= NSFW_MEM_TYPEMAX))
+    {
+      NSCOMM_LOGERR ("zone create input para error] pinfo=%p, mtype=%d",
+                     pinfo, pinfo ? pinfo->stname.entype : (-1));
+      return NULL;
+    }
+
+  MEM_OP_CALL_OK_RET (pinfo->stname.entype, mem_ops_zone_creae, (pinfo));
+  NSCOMM_LOGINF ("mem create fail] memtype=%d, name=%s, size=%zu",
+                 pinfo->stname.entype, pinfo->stname.aname, pinfo->lenth);
+  return NULL;
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_mem_zone_createv
+*   Description  : create some memory blocks
+*   note         : 1. the lenth of name must be less than NSFW_MEM_APPNAME_LENTH.
+*   Input        : nsfw_mem_zone* pmeminfo
+*                  i32 inum
+*                  mzone_handle* paddr_array
+*                  i32 iarray_num
+*   Output       : None
+*   Return Value : i32
+*   Calls        :
+*   Called By    :
+*
+*****************************************************************************/
+i32
+nsfw_mem_zone_createv (nsfw_mem_zone * pmeminfo, i32 inum,
+                       mzone_handle * paddr_array, i32 iarray_num)
+{
+  if ((NULL == pmeminfo) || (NULL == paddr_array)
+      || (inum != iarray_num) || (inum <= 0)
+      || (pmeminfo[0].stname.entype >= NSFW_MEM_TYPEMAX))
+    {
+      NSCOMM_LOGERR
+        ("input para error] pmeminfo=%p, inum=%d, paddr_array=%p, iarray_num=%d, mtype=%d",
+         pmeminfo, inum, paddr_array, iarray_num,
+         pmeminfo ? pmeminfo[0].stname.entype : (-1));
+      return NSFW_MEM_ERR;
+    }
+
+  MEM_OP_CALL_OK_RET (pmeminfo[0].stname.entype, mem_ops_zone_createv,
+                      (pmeminfo, inum, paddr_array, iarray_num));
+  NSCOMM_LOGINF ("mem create fail] memtype=%d", pmeminfo[0].stname.entype);
+  return NSFW_MEM_ERR;
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_mem_zone_lookup
+*   Description  : look up a memory
+*                  1. the lenth of name must be less than NSFW_MEM_APPNAME_LENTH.
+*                  2. if the memory is shared, pname->enowner indicate that who create this memory.
+*   note         : 1. when calling any shared memory create inferface, the name of memory end with _0 created by nStackMain,
+*                     end with none created by nStackMaster, and end with _<pid> created by other.
+*                  2. pname->enowner is available only when call look up shared memory.
+*                  3. if the roles of process is NSFW_PROC_MASTER but the memory was created by others, or pname->enowner is NSFW_PROC_NULL,
+*                     the name must be full name.
+*                     for examles if the memory was created by nStackMain and pname->enowner is NSFW_PROC_NULL,
+*                     must add '_0' at the end of name, if the memory was created by app and the role of process is NSFW_PROC_MASTER, must add
+*                     _(pid) at the end of name, nstack_123.
+*   Input        : nsfw_mem_name* pname
+*   Output       : None
+*   Return Value : mzone_handle
+*   Calls        :
+*   Called By    :
+*
+*****************************************************************************/
+mzone_handle
+nsfw_mem_zone_lookup (nsfw_mem_name * pname)
+{
+  NSFW_MEM_NAME_CHECK_RET_NULL (pname, "mem zone look up");
+  MEM_OP_CALL_OK_RET (pname->entype, mem_ops_zone_lookup, (pname));
+  NSCOMM_LOGERR ("mem lookup fail] memtype=%d, name=%s ", pname->entype,
+                 pname->aname);
+  return NULL;
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_mem_zone_release
+*   Description  : release a memory
+*   Input        : nsfw_mem_name* pname
+*   Output       : None
+*   Return Value : i32
+*   Calls        :
+*   Called By    :
+*
+*****************************************************************************/
+i32
+nsfw_mem_zone_release (nsfw_mem_name * pname)
+{
+  NSFW_MEM_NAME_CHECK_RET_ERR (pname, "mem zone release");
+  MEM_OP_CALL_OK_RET (pname->entype, mem_ops_mzone_release, (pname));
+  NSCOMM_LOGERR ("mem release fail] memtype=%d, name=%s", pname->entype,
+                 pname->aname);
+  return NSFW_MEM_ERR;
+
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_mem_mbfmp_create
+*   Description  : create a mbuf pool
+*   Input        : nsfw_mem_mbfpool* pbufinfo
+*   Output       : None
+*   Return Value : mpool_handle
+*   Calls        :
+*   Called By    :
+*
+*****************************************************************************/
+mpool_handle
+nsfw_mem_mbfmp_create (nsfw_mem_mbfpool * pbufinfo)
+{
+  if ((NULL == pbufinfo) || (pbufinfo->stname.entype >= NSFW_MEM_TYPEMAX))
+    {
+      NSCOMM_LOGERR ("input para error] pbufinfo=%p, mtype=%d", pbufinfo,
+                     pbufinfo ? pbufinfo->stname.entype : (-1));
+      return NULL;
+    }
+
+  MEM_OP_CALL_OK_RET (pbufinfo->stname.entype, mem_ops_mbfmp_create,
+                      (pbufinfo));
+  NSCOMM_LOGERR ("mbufmp create fail] memtype=%d, name=%s ",
+                 pbufinfo->stname.entype, pbufinfo->stname.aname);
+  return NULL;
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_mem_mbfmp_createv
+*   Description  : create some mbuf pools
+*                  1. the name of lenth must be less than NSFW_MEM_APPNAME_LENTH.
+*   Input        : nsfw_mem_mbfpool* pmbfname
+*                  i32 inum
+*                  mpool_handle* phandle_array
+*                  i32 iarray_num
+*   Output       : None
+*   Return Value : i32
+*   Calls        :
+*   Called By    :
+*
+*****************************************************************************/
+i32
+nsfw_mem_mbfmp_createv (nsfw_mem_mbfpool * pmbfname, i32 inum,
+                        mpool_handle * phandle_array, i32 iarray_num)
+{
+  if ((NULL == pmbfname) || (NULL == phandle_array)
+      || (inum != iarray_num) || (inum <= 0)
+      || (pmbfname[0].stname.entype >= NSFW_MEM_TYPEMAX))
+    {
+      NSCOMM_LOGERR
+        ("input para error] pmbfname=%p, inum=%d, phandle_array=%p, iarray_num=%d",
+         pmbfname, inum, phandle_array, iarray_num,
+         pmbfname ? pmbfname[0].stname.entype : (-1));
+      return NSFW_MEM_ERR;
+    }
+
+  MEM_OP_CALL_OK_RET (pmbfname[0].stname.entype, mem_ops_mbfmp_createv,
+                      (pmbfname, inum, phandle_array, iarray_num));
+  NSCOMM_LOGERR ("mbufmp createv fail] memtype=%d",
+                 pmbfname[0].stname.entype);
+  return NSFW_MEM_ERR;
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_mem_mbf_alloc
+*   Description  : alloc a mbuf from mbuf pool
+*   Input        : mpool_handle mhandle
+*                  nsfw_mem_type entype
+*   Output       : None
+*   Return Value : mbuf_handle
+*   Calls        :
+*   Called By    :
+*****************************************************************************/
+mbuf_handle
+nsfw_mem_mbf_alloc (mpool_handle mhandle, nsfw_mem_type entype)
+{
+  NSFW_MEM_MBUF_CHECK_RET_NULL (mhandle, entype, "mbf alloc");
+  MEM_OP_CALL_OK_RET (entype, mem_ops_mbf_alloc, (mhandle));
+  NSCOMM_LOGERR ("mbf alloc fail] handle=%p, type=%d", mhandle, entype);
+  return NULL;
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_mem_mbf_free
+*   Description  : put a mbuf backintp mbuf pool
+*   Input        : mbuf_handle mhandle
+*                  nsfw_mem_type entype
+*   Output       : None
+*   Return Value : i32
+*   Calls        :
+*   Called By    :
+*
+*****************************************************************************/
+i32
+nsfw_mem_mbf_free (mbuf_handle mhandle, nsfw_mem_type entype)
+{
+  NSFW_MEM_MBUF_CHECK_RET_ERR (mhandle, entype, "mbuf free");
+  MEM_OP_CALL_OK_RET (entype, mem_ops_mbf_free, (mhandle));
+  NSCOMM_LOGERR ("mbf free fail] handle=%p, type=%d", mhandle, entype);
+  return NSFW_MEM_ERR;
+
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_mem_mbfmp_lookup
+*   Description  : look up mbuf mpool
+*                  1. the lenth of name must be less than NSFW_MEM_APPNAME_LENTH.
+*                  2. if the memory is shared, pname->enowner indicate that who create this memory.
+*   note         : 1. when calling any shared memory create inferface, the name of memory end with _0 created by nStackMain,
+*                     end with none created by nStackMaster, and end with _<pid> created by other.
+*                  2. pname->enowner is available only when call look up shared memory.
+*                  3. if the roles of process is NSFW_PROC_MASTER but the memory was created by others, or pname->enowner is NSFW_PROC_NULL,
+*                     the name must be full name.
+*                     for examles if the memory was created by nStackMain and pname->enowner is NSFW_PROC_NULL,
+*                     must add '_0' at the end of name, if the memory was created by app and the role of process is NSFW_PROC_MASTER, must add
+*                     _(pid) at the end of name, nstack_123.
+*   Input        : nsfw_mem_name* pmbfname
+*   Output       : None
+*   Return Value : mpool_handle
+*   Calls        :
+*   Called By    :
+*
+*****************************************************************************/
+mpool_handle
+nsfw_mem_mbfmp_lookup (nsfw_mem_name * pmbfname)
+{
+  NSFW_MEM_NAME_CHECK_RET_NULL (pmbfname, "mbuf pool look up");
+  MEM_OP_CALL_OK_RET (pmbfname->entype, mem_ops_mbfmp_lookup, (pmbfname));
+  NSCOMM_LOGERR ("mbufmp lookup fail] memtype=%d, name=%s ", pmbfname->entype,
+                 pmbfname->aname);
+  return NULL;
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_mem_mbfmp_release
+*   Description  : release mbuf pool
+*   note         : 1. the lenth of name must be less than NSFW_MEM_APPNAME_LENTH.
+*   Input        : nsfw_mem_name* pname
+*   Output       : None
+*   Return Value : i32
+*   Calls        :
+*   Called By    :
+*
+*****************************************************************************/
+i32
+nsfw_mem_mbfmp_release (nsfw_mem_name * pname)
+{
+  NSFW_MEM_NAME_CHECK_RET_ERR (pname, "mbuf mp release");
+  MEM_OP_CALL_OK_RET (pname->entype, mem_ops_mbfmp_release, (pname));
+  NSCOMM_LOGERR ("mbfmp release fail] memtype=%d, name=%s", pname->entype,
+                 pname->aname);
+  return NSFW_MEM_ERR;
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_mem_sp_create
+*   Description  : create a simple pool
+*   note         : 1. the lenth of name must be less than NSFW_MEM_APPNAME_LENTH.
+*   Input        : nsfw_mem_sppool* pmpinfo
+*   Output       : None
+*   Return Value : mring_handle
+*   Calls        :
+*   Called By    :
+*
+*****************************************************************************/
+mring_handle
+nsfw_mem_sp_create (nsfw_mem_sppool * pmpinfo)
+{
+  if ((NULL == pmpinfo) || (pmpinfo->stname.entype >= NSFW_MEM_TYPEMAX))
+    {
+      NSCOMM_LOGERR ("input para error] pmpinfo=%p, mtype=%d", pmpinfo,
+                     pmpinfo ? pmpinfo->stname.entype : (-1));
+      return NULL;
+    }
+
+  MEM_OP_CALL_OK_RET (pmpinfo->stname.entype, mem_ops_sp_create, (pmpinfo));
+  NSCOMM_LOGERR ("sp create fail] memtype=%d, name=%s ",
+                 pmpinfo->stname.entype, pmpinfo->stname.aname);
+  return NULL;
+
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_mem_sp_createv
+*   Description  : create some simple pools one time
+*   note         : 1. the lenth of name must be less than NSFW_MEM_APPNAME_LENTH.
+*   Input        : nsfw_mem_sppool* pmpinfo
+*                  i32 inum
+*                  mring_handle* pringhandle_array
+*                  i32 iarray_num
+*   Output       : None
+*   Return Value : i32
+*   Calls        :
+*   Called By    :
+*
+*****************************************************************************/
+i32
+nsfw_mem_sp_createv (nsfw_mem_sppool * pmpinfo, i32 inum,
+                     mring_handle * pringhandle_array, i32 iarray_num)
+{
+  NSFW_MEM_RINGV_CHECK_RET (pmpinfo, inum, pringhandle_array, iarray_num);
+  MEM_OP_CALL_OK_RET (pmpinfo[0].stname.entype, mem_ops_sp_createv,
+                      (pmpinfo, inum, pringhandle_array, iarray_num));
+  NSCOMM_LOGERR ("sp createv fail] memtype=%d", pmpinfo[0].stname.entype);
+  return NSFW_MEM_ERR;
+
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_mem_sp_ring_create
+*   Description  : create a simple pool with many rings
+*   note         : 1. the lenth of name must be less than NSFW_MEM_APPNAME_LENTH.
+*   Input        : nsfw_mem_mring* pringinfo
+*                  mring_handle* pringhandle_array
+*                  i32 iringnum
+*   Output       : None
+*   Return Value : i32
+*   Calls        :
+*   Called By    :
+*
+*****************************************************************************/
+i32
+nsfw_mem_sp_ring_create (nsfw_mem_mring * pringinfo,
+                         mring_handle * pringhandle_array, i32 iringnum)
+{
+  NSFW_MEM_RING_CHECK_RET (pringinfo, pringhandle_array, iringnum);
+  MEM_OP_CALL_OK_RET (pringinfo[0].stname.entype, mem_ops_spring_create,
+                      (pringinfo, pringhandle_array, iringnum));
+  NSCOMM_LOGERR ("mppool spring creat fail] memtype=%d",
+                 pringinfo[0].stname.entype);
+  return NSFW_MEM_ERR;
+
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_mem_sp_release
+*   Description  : release a simple mempool
+*   note         : 1. the lenth of name must be less than NSFW_MEM_APPNAME_LENTH.
+*   Input        : nsfw_mem_name* pname
+*   Output       : None
+*   Return Value : i32
+*   Calls        :
+*   Called By    :
+*****************************************************************************/
+i32
+nsfw_mem_sp_release (nsfw_mem_name * pname)
+{
+  NSFW_MEM_NAME_CHECK_RET_ERR (pname, "sp release");
+  MEM_OP_CALL_OK_RET (pname->entype, mem_ops_sp_release, (pname));
+  NSCOMM_LOGERR ("sp release fail] memtype=%d, name=%s ", pname->entype,
+                 pname->aname);
+  return NSFW_MEM_ERR;
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_mem_sp_lookup
+*   Description  : look up a simpile ring
+*                  1. the lenth of name must be less than NSFW_MEM_APPNAME_LENTH.
+*                  2. if the memory is shared, pname->enowner indicate that who create this memory.
+*   note         : 1. when calling any shared memory create inferface, the name of memory end with _0 created by nStackMain,
+*                     end with none created by nStackMaster, and end with _<pid> created by other.
+*                  2. pname->enowner is available only when call look up shared memory.
+*                  3. if the roles of process is NSFW_PROC_MASTER but the memory was created by others, or pname->enowner is NSFW_PROC_NULL,
+*                     the name must be full name.
+*                     for examles if the memory was created by nStackMain and pname->enowner is NSFW_PROC_NULL,
+*                     must add '_0' at the end of name, if the memory was created by app and the role of process is NSFW_PROC_MASTER, must add
+*                     _(pid) at the end of name, nstack_123.
+*   Input        : nsfw_mem_name* pname
+*   Output       : None
+*   Return Value : mring_handle
+*   Calls        :
+*   Called By    :
+*
+*****************************************************************************/
+mring_handle
+nsfw_mem_sp_lookup (nsfw_mem_name * pname)
+{
+  NSFW_MEM_NAME_CHECK_RET_NULL (pname, "sp look up");
+  MEM_OP_CALL_OK_RET (pname->entype, mem_ops_sp_lookup, (pname));
+  NSCOMM_LOGERR ("sp lookup fail] memtype=%d, name=%s", pname->entype,
+                 pname->aname);
+  return NULL;
+
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_mem_ring_create
+*   Description  : create a ring
+*   note         : 1. the lenth of name must be less than NSFW_MEM_APPNAME_LENTH.
+*                  2. shared memory ring (NSFW_SHMEM) just can put a pointor into the queue, the queue also point to a shared block memory.
+*                     no shared memory ring(NSFW_NSHMEM) is other wise.
+*   Input        : nsfw_mem_mring* pringinfo
+*   Output       : None
+*   Return Value : mring_handle
+*   Calls        :
+*   Called By    :
+*
+*****************************************************************************/
+mring_handle
+nsfw_mem_ring_create (nsfw_mem_mring * pringinfo)
+{
+  if ((NULL == pringinfo) || (pringinfo->stname.entype >= NSFW_MEM_TYPEMAX))
+    {
+      NSCOMM_LOGERR ("input para error] pmpinfo=%p, mtype=%d", pringinfo,
+                     pringinfo ? pringinfo->stname.entype : (-1));
+      return NULL;
+    }
+
+  MEM_OP_CALL_OK_RET (pringinfo->stname.entype, mem_ops_ring_create,
+                      (pringinfo));
+  NSCOMM_LOGERR ("ring create fail] memtype=%d, name=%s ",
+                 pringinfo->stname.entype, pringinfo->stname.aname);
+  return NULL;
+
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_mem_ring_lookup
+*   Description  : look up a ring by name
+*       1. the lenth of name must be less than NSFW_MEM_APPNAME_LENTH.
+*       2. if the memory is shared, pname->enowner indicate that who create this memory.
+*           note:
+*           1. when calling any shared memory create inferface, the name of memory end with _0 created by nStackMain,
+*              end with none created by nStackMaster, and end with _<pid> created by other.
+*           2. pname->enowner is available only when call look up shared memory.
+*           3. if the roles of process is NSFW_PROC_MASTER but the memory was created by others, or pname->enowner is NSFW_PROC_NULL,
+*              the name must be full name.
+*              for examles if the memory was created by nStackMain and pname->enowner is NSFW_PROC_NULL,
+*              must add '_0' at the end of name, if the memory was created by app and the role of process is NSFW_PROC_MASTER, must add
+*              _(pid) at the end of name, nstack_123.
+*   Input        : nsfw_mem_name* pname
+*   Output       : None
+*   Return Value : mring_handle
+*   Calls        :
+*   Called By    :
+*
+*
+*****************************************************************************/
+mring_handle
+nsfw_mem_ring_lookup (nsfw_mem_name * pname)
+{
+  NSFW_MEM_NAME_CHECK_RET_NULL (pname, "ring lookup");
+  MEM_OP_CALL_OK_RET (pname->entype, mem_ops_ring_lookup, (pname));
+  NSCOMM_LOGERR ("ring lookup fail] memtype=%d, name=%s", pname->entype,
+                 pname->aname);
+  return NULL;
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_mem_ring_reset
+*   Description  : reset the number of producer and consumer, also, the
+*                  state of ring reset to empty
+*   notes        : must be called before doing any operations base on the ring
+*   Input        : mring_handle mhandle
+*                  nsfw_mpool_type entype
+*   Output       : None
+*   Return Value : void
+*   Calls        :
+*   Called By    :
+*
+*****************************************************************************/
+void
+nsfw_mem_ring_reset (mring_handle mhandle, nsfw_mpool_type entype)
+{
+  u32 loop = 0;
+  struct nsfw_mem_ring *ring = (struct nsfw_mem_ring *) mhandle;
+
+  if (!ring)
+    {
+      return;
+    }
+
+  ring->prod.head = 0;
+  ring->cons.tail = 0;
+  ring->ringflag = (u8) entype;
+
+  /*init Ring */
+  for (loop = 0; loop < ring->size; loop++)
+    {
+      /*
+         for a empty ring, version is the mapping head val - size
+         so the empty ring's ver is loop-size;
+       */
+      ring->ring[loop].data_s.ver = (loop - ring->size);
+      ring->ring[loop].data_s.val = 0;
+    }
+
+  return;
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_mem_ring_free_count
+*   Description  : get the free number of ring
+*   Input        : mring_handle mhandle
+*   Output       : None
+*   Return Value : u32
+*   Calls        :
+*   Called By    :
+*
+*****************************************************************************/
+u32
+nsfw_mem_ring_free_count (mring_handle mhandle)
+{
+  struct nsfw_mem_ring *temp = NULL;
+  u32 thead = 0;
+  u32 ttail = 0;
+  if (NULL == mhandle)
+    {
+      NSCOMM_LOGERR ("input para error] mhandle=%p", mhandle);
+      return 0;
+    }
+
+  temp = (struct nsfw_mem_ring *) mhandle;
+  thead = temp->prod.head;
+  ttail = temp->cons.tail;
+  return ttail + temp->size - thead;
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_mem_ring_using_count
+*   Description  : get the in using number of ring
+*   Input        : mring_handle mhandle
+*   Output       : None
+*   Return Value : u32
+*   Calls        :
+*   Called By    :
+*
+*****************************************************************************/
+u32
+nsfw_mem_ring_using_count (mring_handle mhandle)
+{
+  struct nsfw_mem_ring *temp = NULL;
+  u32 thead = 0;
+  u32 ttail = 0;
+  if (NULL == mhandle)
+    {
+      NSCOMM_LOGERR ("input para error] mhandle=%p", mhandle);
+      return 0;
+    }
+
+  temp = (struct nsfw_mem_ring *) mhandle;
+  thead = temp->prod.head;
+  ttail = temp->cons.tail;
+  return thead - ttail;
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_mem_ring_size
+*   Description  : get size of ring
+*   Input        : mring_handle mhandle
+*   Output       : None
+*   Return Value : u32
+*   Calls        :
+*   Called By    :
+*****************************************************************************/
+u32
+nsfw_mem_ring_size (mring_handle mhandle)
+{
+  struct nsfw_mem_ring *temp = NULL;
+
+  if (NULL == mhandle)
+    {
+      NSCOMM_LOGERR ("input para error] mhandle=%p", mhandle);
+      return 0;
+    }
+
+  temp = (struct nsfw_mem_ring *) mhandle;
+
+  return temp->size;
+}
+
+#ifdef SYS_MEM_RES_STAT
+/*****************************************************************************
+*   Prototype    : nsfw_mem_mbfpool_free_count
+*   Description  : get the free mbuf count of a mbuf pool
+*   Input        : mpool_handle mhandle
+*   Output       : None
+*   Return Value : u32
+*   Calls        :
+*   Called By    :
+*
+*****************************************************************************/
+u32
+nsfw_mem_mbfpool_free_count (mpool_handle mhandle)
+{
+  if (!mhandle)
+    {
+      NSCOMM_LOGERR ("input para error] mhandle=%p", mhandle);
+      return 0;
+    }
+  struct common_mem_mempool *mp = (struct common_mem_mempool *) mhandle;
+  struct common_mem_ring *mp_ring =
+    (struct common_mem_ring *) (mp->ring_align);
+  if (!mp_ring)
+    {
+      NSCOMM_LOGERR ("ring is null");
+      return 0;
+    }
+  u32 p_head = mp_ring->prod.head;
+  u32 c_tail = mp_ring->cons.tail;
+
+  return p_head - c_tail;
+}
+#endif /* SYS_MEM_RES_STAT */
+
+/*****************************************************************************
+*   Prototype    : nsfw_mem_ring_release
+*   Description  : release a ring memory
+*   notes        : the lenth of name must be less than NSFW_MEM_APPNAME_LENTH
+*   Input        : nsfw_mem_name* pname
+*   Output       : None
+*   Return Value : i32
+*   Calls        :
+*   Called By    :
+*****************************************************************************/
+i32
+nsfw_mem_ring_release (nsfw_mem_name * pname)
+{
+  NSFW_MEM_NAME_CHECK_RET_ERR (pname, "ring release");
+  MEM_OP_CALL_OK_RET (pname->entype, mem_ops_ring_release, (pname));
+  NSCOMM_LOGERR ("ring release fail] name=%s, type=%d", pname->aname,
+                 pname->entype);
+  return NSFW_MEM_ERR;
+
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_mem_get_len
+*   Description  : statics mbufpool, sppool, ring mem size.
+*                  return: <=0, err happen, >0 mem size
+*                  NSFW_MEM_MZONE: not surport because you already know the lenth when create
+*   Input        : void * handle
+*                  nsfw_mem_struct_type type
+*   Output       : None
+*   Return Value : ssize_t
+*   Calls        :
+*   Called By    :
+*****************************************************************************/
+ssize_t
+nsfw_mem_get_len (void *handle, nsfw_mem_struct_type type)
+{
+  if (NULL == handle)
+    {
+      NSCOMM_LOGERR ("input para error] handle=%p", handle);
+      return -1;
+    }
+  if ((NSFW_MEM_SPOOL == type) || (NSFW_MEM_RING == type))
+    {
+      struct nsfw_mem_ring *ring = (struct nsfw_mem_ring *) handle;
+      if (ring->memtype >= NSFW_MEM_TYPEMAX)
+        {
+          NSCOMM_LOGERR ("invalid ring] ring type=%u ,handle=%p",
+                         ring->memtype, handle);
+          return -1;
+        }
+      MEM_OP_CALL_OK_RET (ring->memtype, mem_ops_mem_statics, (handle, type));
+    }
+  else
+    {
+      MEM_OP_CALL_OK_RET (NSFW_SHMEM, mem_ops_mem_statics, (handle, type));
+    }
+  return -1;
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_mem_mbuf_pool_recycle
+*   Description  : recycle mbuf
+*   Input        : mpool_handle handle
+*   Output       : None
+*   Return Value : i32
+*   Calls        :
+*   Called By    :
+*****************************************************************************/
+i32
+nsfw_mem_mbuf_pool_recycle (mpool_handle handle)
+{
+  MEM_OP_CALL_OK_RET (NSFW_SHMEM, mem_ops_mbuf_recycle, (handle));
+  return -1;
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_mem_sp_iterator
+*   Description  : spool 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_mem_sp_iterator (mpool_handle handle, u32 start, u32 end,
+                      nsfw_mem_item_fun fun, void *argv)
+{
+  MEM_OP_CALL_OK_RET (NSFW_SHMEM, mem_ops_sp_iterator,
+                      (handle, start, end, fun, argv));
+  return -1;
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_mem_mbuf_iterator
+*   Description  : mbuf 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_mem_mbuf_iterator (mpool_handle handle, u32 start, u32 end,
+                        nsfw_mem_item_fun fun, void *argv)
+{
+  MEM_OP_CALL_OK_RET (NSFW_SHMEM, mem_ops_mbuf_iterator,
+                      (handle, start, end, fun, argv));
+  return -1;
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_mem_dfx_ring_print
+*   Description  : print ring info
+*   Input        : mring_handle mhandle
+*   Output       : None
+*   Return Value : if no err happen, return the lenth of string print, 0 or -1 maybe err happen
+*   Calls        :
+*   Called By    :
+*****************************************************************************/
+i32
+nsfw_mem_dfx_ring_print (mring_handle mhandle, char *pbuf, int lenth)
+{
+  struct nsfw_mem_ring *temp = (struct nsfw_mem_ring *) mhandle;
+  u32 head = 0;
+  u32 tail = 0;
+  int ret = 0;
+  if ((!temp) || (!pbuf) || (lenth <= 0))
+    {
+      return 0;
+    }
+  head = temp->prod.head;
+  tail = temp->cons.tail;
+  ret =
+    SPRINTF_S (pbuf, lenth,
+               "[.Head=%u,\n .Tail=%u,\n .(|Tail-Head|)=%u,\n .size=%u,\n .mask=%u]\n",
+               head, tail, (tail >= head) ? (tail - head) : (head - tail),
+               temp->size, temp->mask);
+  return ret;
+}
diff --git a/src/framework/common/mem_mgr/nsfw_mem_construct.c b/src/framework/common/mem_mgr/nsfw_mem_construct.c
new file mode 100644
index 0000000..ed6fe27
--- /dev/null
+++ b/src/framework/common/mem_mgr/nsfw_mem_construct.c
@@ -0,0 +1,21 @@
+/*
+*
+* 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 "nsfw_init.h"
+#include "nsfw_mem_api.h"
+
+NSFW_MODULE_NAME (NSFW_MEM_MGR_MODULE)
+NSFW_MODULE_PRIORITY (10) NSFW_MODULE_INIT (nsfw_mem_init)
diff --git a/src/framework/common/mem_mgr/nsfw_mem_desc.c b/src/framework/common/mem_mgr/nsfw_mem_desc.c
new file mode 100644
index 0000000..d0fbfd3
--- /dev/null
+++ b/src/framework/common/mem_mgr/nsfw_mem_desc.c
@@ -0,0 +1,92 @@
+/*
+*
+* 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 <sys/types.h>
+#include <unistd.h>
+#include "nsfw_mem_desc.h"
+#include "nsfw_shmem_mdesc.h"
+#include "nsfw_nshmem_mdesc.h"
+#include "nsfw_shmem_ring.h"
+#include "nsfw_nshmem_ring.h"
+
+/* *INDENT-OFF* */
+/*the order you add must be NSFW_SHMEM, NSFW_NSHMEM*/
+nsfw_mem_attr g_nsfw_mem_ops[] =
+{
+    {NSFW_SHMEM, &g_shmem_ops},
+    {NSFW_NSHMEM, &g_nshmem_ops},
+};
+
+i32 g_mem_type_num = sizeof(g_nsfw_mem_ops) / sizeof(nsfw_mem_attr);
+
+
+nsfw_ring_ops g_ring_ops_arry[NSFW_MEM_TYPEMAX][NSFW_MPOOL_TYPEMAX] = {
+    {
+        {
+            (nsfw_mem_ring_enqueue_fun)nsfw_shmem_ring_sp_enqueue, \
+            (nsfw_mem_ring_dequeue_fun)nsfw_shmem_ring_sc_dequeue, \
+            (nsfw_mem_ring_dequeuev_fun)nsfw_shmem_ring_sc_dequeuev
+        },
+        {
+            (nsfw_mem_ring_enqueue_fun)nsfw_shmem_ring_mp_enqueue, \
+            (nsfw_mem_ring_dequeue_fun)nsfw_shmem_ring_sc_dequeue, \
+            (nsfw_mem_ring_dequeuev_fun)nsfw_shmem_ring_sc_dequeuev
+        },
+        {
+            (nsfw_mem_ring_enqueue_fun)nsfw_shmem_ring_sp_enqueue, \
+            (nsfw_mem_ring_dequeue_fun)nsfw_shmem_ring_mc_dequeue, \
+            (nsfw_mem_ring_dequeuev_fun)nsfw_shmem_ring_mc_dequeuev
+        },
+        {
+            (nsfw_mem_ring_enqueue_fun)nsfw_shmem_ring_mp_enqueue, \
+            (nsfw_mem_ring_dequeue_fun)nsfw_shmem_ring_mc_dequeue, \
+            (nsfw_mem_ring_dequeuev_fun)nsfw_shmem_ring_mc_dequeuev
+        },
+        {
+            (nsfw_mem_ring_enqueue_fun)nsfw_shmem_ring_singlethread_enqueue, \
+            (nsfw_mem_ring_dequeue_fun)nsfw_shmem_ring_singlethread_dequeue, \
+            (nsfw_mem_ring_dequeuev_fun)nsfw_shmem_ring_singlethread_dequeuev
+        }
+    },
+    {
+        {
+            (nsfw_mem_ring_enqueue_fun)nsfw_nshmem_ring_sp_enqueue, \
+            (nsfw_mem_ring_dequeue_fun)nsfw_nshmem_ring_sc_dequeue, \
+            (nsfw_mem_ring_dequeuev_fun)nsfw_nshmem_ring_sc_dequeuev
+        },
+        {
+            (nsfw_mem_ring_enqueue_fun)nsfw_nshmem_ring_mp_enqueue, \
+            (nsfw_mem_ring_dequeue_fun)nsfw_nshmem_ring_sc_dequeue, \
+            (nsfw_mem_ring_dequeuev_fun)nsfw_nshmem_ring_sc_dequeuev
+        },
+        {
+            (nsfw_mem_ring_enqueue_fun)nsfw_nshmem_ring_sp_enqueue, \
+            (nsfw_mem_ring_dequeue_fun)nsfw_nshmem_ring_mc_dequeue, \
+            (nsfw_mem_ring_dequeuev_fun)nsfw_nshmem_ring_mc_dequeuev
+        },
+        {
+            (nsfw_mem_ring_enqueue_fun)nsfw_nshmem_ring_mp_enqueue, \
+            (nsfw_mem_ring_dequeue_fun)nsfw_nshmem_ring_mc_dequeue, \
+            (nsfw_mem_ring_dequeuev_fun)nsfw_nshmem_ring_mc_dequeuev
+        },
+        {
+            (nsfw_mem_ring_enqueue_fun)nsfw_nshmem_ring_singlethread_enqueue, \
+            (nsfw_mem_ring_dequeue_fun)nsfw_nshmem_ring_singlethread_dequeue, \
+            (nsfw_mem_ring_dequeuev_fun)nsfw_nshmem_ring_singlethread_dequeuev
+        }
+    }
+};
+/* *INDENT-ON* */
diff --git a/src/framework/common/mem_mgr/nsfw_mem_stat.c b/src/framework/common/mem_mgr/nsfw_mem_stat.c
new file mode 100644
index 0000000..f7a1f41
--- /dev/null
+++ b/src/framework/common/mem_mgr/nsfw_mem_stat.c
@@ -0,0 +1,292 @@
+/*
+*
+* 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 <stdlib.h>
+#include "types.h"
+#include "nstack_securec.h"
+#include "nsfw_init.h"
+
+#include "nstack_log.h"
+#include "nsfw_maintain_api.h"
+#include "nsfw_mem_api.h"
+
+#ifdef __cplusplus
+/* *INDENT-OFF* */
+extern "C"{
+/* *INDENT-ON* */
+#endif /* __cplusplus */
+
+#define NSFW_MEM_STAT_NUM  512
+
+#define NSFW_MEM_STAT_MODULE "nsfw_mem_stat_module"
+
+typedef struct _nsfw_mem_stat
+{
+  u8 mem_type;
+  u8 alloc_flag;
+  char module[NSFW_MEM_MODULE_LEN];
+  char mem_name[NSFW_MEM_NAME_LEN];
+  u32 mem_size;
+} nsfw_mem_stat_t;
+
+nsfw_mem_stat_t g_mem_stat[NSFW_MEM_STAT_NUM];
+
+#ifdef SYS_MEM_RES_STAT
+#define MAX_STAT_ITEM_NUM 20
+typedef struct _mem_stat_item_t
+{
+  char name[32];
+  u64 size;
+} mem_stat_item_t;
+
+typedef struct _mem_stat_mgr_t
+{
+  u32 item_num;
+  mem_stat_item_t item[MAX_STAT_ITEM_NUM];
+} mem_stat_mgr;
+
+mem_stat_mgr g_max_mem_list;
+#endif
+
+/*****************************************************************************
+*   Prototype    : nsfw_mem_stat
+*   Description  : add memory stat
+*   Input        : char *module
+*                  char *mem_name
+*                  u8 mem_type
+*                  u32 mem_size
+*   Output       : None
+*   Return Value : void
+*   Calls        :
+*   Called By    :
+*
+*****************************************************************************/
+void
+nsfw_mem_stat (char *module, char *mem_name, u8 mem_type, u32 mem_size)
+{
+  if (NULL == module || NULL == mem_name)
+    {
+      NSFW_LOGERR ("argv err]module=%p,mem_name=%p", module, mem_name);
+      return;
+    }
+
+  int i;
+  nsfw_mem_stat_t *mem_stat_item = NULL;
+  for (i = 0; i < NSFW_MEM_STAT_NUM; i++)
+    {
+      if (FALSE == g_mem_stat[i].alloc_flag)
+        {
+          g_mem_stat[i].alloc_flag = TRUE;
+          mem_stat_item = &g_mem_stat[i];
+          break;
+        }
+    }
+
+  if (NULL == mem_stat_item)
+    {
+      NSFW_LOGERR ("mem stat full]module=%s,type=%u,name=%s,size=%u",
+                   module, mem_type, mem_name, mem_size);
+      return;
+    }
+
+  mem_stat_item->mem_type = mem_type;
+  mem_stat_item->mem_size = mem_size;
+
+  if (EOK != STRCPY_S (mem_stat_item->module, NSFW_MEM_MODULE_LEN, module))
+    {
+      NSFW_LOGERR ("STRNCPY_S failed");
+      return;
+    }
+  if (EOK != STRCPY_S (mem_stat_item->mem_name, NSFW_MEM_NAME_LEN, mem_name))
+    {
+      NSFW_LOGERR ("STRNCPY_S failed");
+      return;
+    }
+
+  return;
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_mem_stat_print
+*   Description  : print all memory info
+*   Input        : None
+*   Output       : None
+*   Return Value : void
+*   Calls        :
+*   Called By    :
+*
+*****************************************************************************/
+void
+nsfw_mem_stat_print ()
+{
+  int i;
+  for (i = 0; i < NSFW_MEM_STAT_NUM; i++)
+    {
+      if (TRUE == g_mem_stat[i].alloc_flag)
+        {
+          NSFW_LOGINF ("mem_module=%s,name=%s,type=%u,size=%u",
+                       g_mem_stat[i].module, g_mem_stat[i].mem_name,
+                       g_mem_stat[i].mem_type, g_mem_stat[i].mem_size);
+        }
+    }
+
+}
+
+#ifdef SYS_MEM_RES_STAT
+void
+clear_mem_stat_item ()
+{
+  if (EOK != MEMSET_S ((char *) &g_max_mem_list, sizeof (mem_stat_mgr),
+                       0, sizeof (mem_stat_mgr)))
+    {
+      NSFW_LOGERR ("MEMSET_S failed");
+    }
+}
+
+void
+insert_mem_stat_item (char *name, u64 len)
+{
+  int j, temp;
+
+  if (g_max_mem_list.item_num == 0)
+    {
+      if (EOK !=
+          STRCPY_S (g_max_mem_list.item[0].name,
+                    sizeof (g_max_mem_list.item[0].name), name))
+        {
+          NSFW_LOGERR ("STRCPY_S failed");
+        }
+      g_max_mem_list.item[0].size = len;
+      g_max_mem_list.item_num++;
+      return;
+    }
+  else if (g_max_mem_list.item_num < MAX_STAT_ITEM_NUM)
+    {
+      if (len <= g_max_mem_list.item[g_max_mem_list.item_num - 1].size)
+        {
+          if (EOK !=
+              STRCPY_S (g_max_mem_list.item[g_max_mem_list.item_num].name,
+                        sizeof (g_max_mem_list.item
+                                [g_max_mem_list.item_num].name), name))
+            {
+              NSFW_LOGERR ("STRCPY_S failed");
+            }
+          g_max_mem_list.item[g_max_mem_list.item_num].size = len;
+          g_max_mem_list.item_num++;
+          return;
+        }
+      j = 0;
+      temp = g_max_mem_list.item_num;
+      while (j < temp)
+        {
+          if (len >= g_max_mem_list.item[j].size)
+            {
+              goto insert_it;
+            }
+          j++;
+        }
+      if (j == temp)
+        {
+          if (EOK !=
+              STRCPY_S (g_max_mem_list.item[j].name,
+                        sizeof (g_max_mem_list.item[j].name), name))
+            {
+              NSFW_LOGERR ("STRCPY_S failed");
+            }
+          g_max_mem_list.item[j].size = len;
+          g_max_mem_list.item_num++;
+          return;
+        }
+    }
+  else
+    {
+      j = 0;
+      temp = MAX_STAT_ITEM_NUM - 1;
+      while (j < MAX_STAT_ITEM_NUM)
+        {
+          if (len >= g_max_mem_list.item[j].size)
+            {
+              goto insert_it;
+            }
+          j++;
+        }
+    }
+
+  return;
+
+insert_it:
+  while (temp - 1 >= j)
+    {
+      if (EOK !=
+          STRCPY_S (g_max_mem_list.item[temp].name,
+                    sizeof (g_max_mem_list.item[temp].name),
+                    g_max_mem_list.item[temp - 1].name))
+        {
+          NSFW_LOGERR ("STRCPY_S failed");
+        }
+      g_max_mem_list.item[temp].size = g_max_mem_list.item[temp - 1].size;
+      temp--;
+    }
+  if (EOK !=
+      STRCPY_S (g_max_mem_list.item[j].name,
+                sizeof (g_max_mem_list.item[j].name), name))
+    {
+      NSFW_LOGERR ("STRCPY_S failed");
+    }
+  g_max_mem_list.item[j].size = len;
+  g_max_mem_list.item_num++;
+  return;
+}
+
+int
+get_mem_stat_item (int idx, char **name, u64 * len)
+{
+  if (idx < 0 || idx >= MAX_STAT_ITEM_NUM)
+    {
+      return -1;
+    }
+
+  *name = g_max_mem_list.item[idx].name;
+  *len = g_max_mem_list.item[idx].size;
+
+  return 0;
+}
+#endif
+
+static int nsfw_mem_stat_init (void *param);
+static int
+nsfw_mem_stat_init (void *param)
+{
+  MEM_STAT (NSFW_MEM_STAT_MODULE, "g_mem_stat", NSFW_NSHMEM,
+            sizeof (g_mem_stat));
+  nsfw_mem_stat_print ();
+#ifdef SYS_MEM_RES_STAT
+  clear_mem_stat_item ();
+#endif
+  return 0;
+}
+
+/* *INDENT-OFF* */
+NSFW_MODULE_NAME (NSFW_MEM_STAT_MODULE)
+NSFW_MODULE_PRIORITY (99)
+NSFW_MODULE_INIT (nsfw_mem_stat_init)
+/* *INDENT-ON* */
+
+#ifdef __cplusplus
+/* *INDENT-OFF* */
+}
+/* *INDENT-ON* */
+#endif /* __cplusplus */
diff --git a/src/framework/common/mem_mgr/nsfw_nshmem/nsfw_nshmem_mdesc.c b/src/framework/common/mem_mgr/nsfw_nshmem/nsfw_nshmem_mdesc.c
new file mode 100644
index 0000000..c78c27e
--- /dev/null
+++ b/src/framework/common/mem_mgr/nsfw_nshmem/nsfw_nshmem_mdesc.c
@@ -0,0 +1,47 @@
+/*
+*
+* 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 "nsfw_mem_desc.h"
+#include "nsfw_nshmem_mng.h"
+#include "nsfw_nshmem_mdesc.h"
+
+/*no share memory access inferface*/
+nsfw_mem_ops g_nshmem_ops = {
+  nsfw_nshmem_init,
+  nsfw_nshmem_destory,
+  nsfw_nshmem_create,
+  NULL,
+  nsfw_nshmem_lookup,
+  nsfw_nshmem_release,
+  NULL,
+  NULL,
+  NULL,
+  NULL,
+  NULL,
+  NULL,
+  nsfw_nshmem_spcreate,
+  NULL,
+  NULL,
+  nsfw_nshmem_sprelease,
+  nsfw_nshmem_sp_lookup,
+  nsfw_nshmem_ringcreate,
+  NULL,
+  nsfw_nshmem_ringrelease,
+  nsfw_nshmem_stactic,
+  NULL,
+  NULL,                         /*mem_ops_sp_iterator */
+  NULL,                         /*mem_ops_mbuf_iterator */
+};
diff --git a/src/framework/common/mem_mgr/nsfw_nshmem/nsfw_nshmem_mdesc.h b/src/framework/common/mem_mgr/nsfw_nshmem/nsfw_nshmem_mdesc.h
new file mode 100644
index 0000000..1b63520
--- /dev/null
+++ b/src/framework/common/mem_mgr/nsfw_nshmem/nsfw_nshmem_mdesc.h
@@ -0,0 +1,22 @@
+/*
+*
+* 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.
+*/
+
+#ifndef _NSFW_NSHMEM_MDESC_H
+#define _NSFW_NSHMEM_MDESC_H
+
+extern nsfw_mem_ops g_nshmem_ops;
+
+#endif
diff --git a/src/framework/common/mem_mgr/nsfw_nshmem/nsfw_nshmem_mng.c b/src/framework/common/mem_mgr/nsfw_nshmem/nsfw_nshmem_mng.c
new file mode 100644
index 0000000..d5661fd
--- /dev/null
+++ b/src/framework/common/mem_mgr/nsfw_nshmem/nsfw_nshmem_mng.c
@@ -0,0 +1,544 @@
+/*
+*
+* 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 <stdlib.h>
+#include "nstack_log.h"
+#include "nstack_securec.h"
+#include "nsfw_mem_desc.h"
+#include "nsfw_ring_fun.h"
+#include "nsfw_nshmem_ring.h"
+#include "nsfw_nshmem_mng.h"
+
+#include "common_func.h"
+
+#define nsfw_get_glb_lock()      (&g_nshmem_internal_cfg->mlock)
+
+#define NSFW_NSHMEM_INIT_CHK_RET_NULL()  \
+    if ((!g_nshmem_internal_cfg) || (!g_nshmem_localdata)) \
+    { \
+        NSCOMM_LOGDBG("Error] g_nshmem_internal_cfg=%p, g_nshmem_localdata=%p", g_nshmem_internal_cfg, g_nshmem_localdata); \
+        return NULL;  \
+    }
+
+#define NSFW_NSHMEM_INIT_CHK_RET()  \
+    if ((!g_nshmem_internal_cfg) || (!g_nshmem_localdata)) \
+    { \
+        NSCOMM_LOGDBG("Error] g_nshmem_internal_cfg=%p, g_nshmem_localdata=%p", g_nshmem_internal_cfg, g_nshmem_localdata); \
+        return NSFW_MEM_ERR;  \
+    }
+
+nsfw_mem_localdata *g_nshmem_localdata = NULL;
+nsfw_nshmem_cfg *g_nshmem_internal_cfg = NULL;
+
+/*look up a mem zone*/
+NSTACK_STATIC inline nsfw_nshmem_mzone *
+nsfw_nshmem_get_free_zone (void)
+{
+  int icnt = 0;
+
+  /*g_nshmem_internal_cfg must not be null if come here */
+  for (icnt = 0; icnt < COMMON_MEM_MAX_MEMZONE; icnt++)
+    {
+      if (g_nshmem_internal_cfg->amemzone[icnt].addr == NULL)
+        {
+          return &g_nshmem_internal_cfg->amemzone[icnt];
+        }
+    }
+
+  return NULL;
+}
+
+NSTACK_STATIC inline void
+nsfw_nshmem_free_zone (nsfw_nshmem_mzone * pzone)
+{
+  nsfw_nshmem_mzone *pzonebase = &g_nshmem_internal_cfg->amemzone[0];
+  nsfw_nshmem_mzone *pzoneend =
+    &g_nshmem_internal_cfg->amemzone[NSFW_NSHMEM_ZONE_MAX - 1];
+
+  if ((((int) ((char *) pzone - (char *) pzonebase) < 0)
+       || ((int) ((char *) pzone - (char *) pzoneend) > 0))
+      && ((unsigned int) ((char *) pzone - (char *) pzonebase) %
+          sizeof (nsfw_nshmem_mzone) != 0))
+    {
+      NSCOMM_LOGERR ("nshmem free fail] mem=%p", pzone);
+      return;
+    }
+  if (pzone->addr)
+    {
+      free (pzone->addr);
+    }
+  pzone->addr = NULL;
+
+  int ret = MEMSET_S ((void *) pzone, sizeof (nsfw_nshmem_mzone), 0,
+                      sizeof (nsfw_nshmem_mzone));
+  if (EOK != ret)
+    {
+      NSCOMM_LOGERR ("MEMSET_S failed] mem=%p, ret=%d", pzone, ret);
+    }
+  return;
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_nshmem_init
+*   Description  : nsh module init
+*   Input        : nsfw_mem_para* para
+*   Output       : None
+*   Return Value : i32
+*   Calls        :
+*   Called By    :
+*****************************************************************************/
+i32
+nsfw_nshmem_init (nsfw_mem_para * para)
+{
+  i32 iret = NSFW_MEM_OK;
+  NSCOMM_LOGINF ("nsfw nshmem init begin");
+  g_nshmem_localdata =
+    (nsfw_mem_localdata *) malloc (sizeof (nsfw_mem_localdata));
+
+  if (NULL == g_nshmem_localdata)
+    {
+      NSCOMM_LOGERR ("nshmem init g_nshmem_localdata malloc fail");
+      return NSFW_MEM_ERR;
+    }
+
+  iret =
+    MEMSET_S (g_nshmem_localdata, sizeof (nsfw_mem_localdata), 0,
+              sizeof (nsfw_mem_localdata));
+
+  if (EOK != iret)
+    {
+      NSCOMM_LOGERR ("nshmem init g_nshmem_localdata MEMSET_S fail");
+      goto ERROR;
+    }
+
+  g_nshmem_internal_cfg =
+    (nsfw_nshmem_cfg *) malloc (sizeof (nsfw_nshmem_cfg));
+
+  if (NULL == g_nshmem_internal_cfg)
+    {
+      NSCOMM_LOGERR ("nshmem init g_nshmem_internal_cfg malloc fail");
+      goto ERROR;
+    }
+
+  iret =
+    MEMSET_S (g_nshmem_internal_cfg, sizeof (nsfw_nshmem_cfg), 0,
+              sizeof (nsfw_nshmem_cfg));
+
+  if (EOK != iret)
+    {
+      NSCOMM_LOGERR ("nshmem init g_nshmem_internal_cfg MEMSET_S fail");
+      goto ERROR;
+    }
+
+  g_nshmem_localdata->enflag = para->enflag;
+  NSCOMM_LOGINF ("nsfw nshmem init end");
+  goto OK;
+
+ERROR:
+  iret = NSFW_MEM_ERR;
+  nsfw_nshmem_destory ();
+  return iret;
+OK:
+  iret = NSFW_MEM_OK;
+  return iret;
+}
+
+/*
+ * memory destory
+ */
+void
+nsfw_nshmem_destory (void)
+{
+  if (g_nshmem_localdata)
+    {
+      free (g_nshmem_localdata);
+      g_nshmem_localdata = NULL;
+    }
+
+  if (g_nshmem_internal_cfg)
+    {
+      free (g_nshmem_internal_cfg);
+      g_nshmem_internal_cfg = NULL;
+    }
+
+  return;
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_nshmem_reserv_safe
+*   Description  : malloc a memory and save to memzone
+*   Input        : const char* name
+*                  size_t lenth
+*   Output       : None
+*   Return Value : mzone_handle
+*   Calls        :
+*   Called By    :
+*
+*****************************************************************************/
+mzone_handle
+nsfw_nshmem_reserv_safe (const char *name, size_t lenth)
+{
+  void *addr = NULL;
+  i32 iret = NSFW_MEM_OK;
+  nsfw_nshmem_mzone *pmemzone = NULL;
+
+  if (lenth <= 0)
+    {
+      return NULL;
+    }
+
+  nsfw_write_lock (nsfw_get_glb_lock ());
+
+  addr = malloc (lenth);
+  if (!addr)
+    {
+      NSCOMM_LOGERR ("nshmem malloc addr fail] addr=%p", addr);
+      nsfw_write_unlock (nsfw_get_glb_lock ());
+      return NULL;
+    }
+
+  iret = MEMSET_S (addr, lenth, 0, lenth);
+  if (EOK != iret)
+    {
+      NSCOMM_LOGERR ("nshmem malloc addr MEMSET_S fail] addr=%p", addr);
+      free (addr);
+      nsfw_write_unlock (nsfw_get_glb_lock ());
+      return NULL;
+    }
+
+  pmemzone = nsfw_nshmem_get_free_zone ();
+
+  if (!pmemzone)
+    {
+      NSCOMM_LOGERR ("nshmem get free zone fail");
+      free (addr);
+      nsfw_write_unlock (nsfw_get_glb_lock ());
+      return NULL;
+    }
+
+  pmemzone->addr = addr;
+  pmemzone->lenth = lenth;
+  /*name must be less than NSFW_MEM_APPNAME_LENTH */
+  if (EOK !=
+      STRCPY_S ((char *) pmemzone->aname, sizeof (pmemzone->aname), name))
+    {
+      NSCOMM_LOGERR ("STRCPY_S failed]name=%s", name);
+      free (addr);
+      nsfw_write_unlock (nsfw_get_glb_lock ());
+      return NULL;
+    }
+
+  nsfw_write_unlock (nsfw_get_glb_lock ());
+  return addr;
+}
+
+/*
+ * create no shared memory
+ * nsfw_mem_zone::stname no shared memory name
+ * nsfw_mem_zone::isize memory size
+ */
+mzone_handle
+nsfw_nshmem_create (nsfw_mem_zone * pinfo)
+{
+
+  NSFW_NAME_LENCHECK_RET_NULL (pinfo->stname.aname, "nshmem create");
+  NSFW_NSHMEM_INIT_CHK_RET_NULL ();
+  return nsfw_nshmem_reserv_safe (pinfo->stname.aname, pinfo->lenth);
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_nshmem_lookup
+*   Description  : find a block memory by name
+*   Input        : nsfw_mem_name* pname
+*   Output       : None
+*   Return Value : mzone_handle
+*   Calls        :
+*   Called By    :
+*
+*****************************************************************************/
+mzone_handle
+nsfw_nshmem_lookup (nsfw_mem_name * pname)
+{
+  int icnt = 0;
+  nsfw_nshmem_mzone *mz = NULL;
+
+  NSFW_NAME_LENCHECK_RET_NULL (pname->aname, "nshmem lookup");
+  NSFW_NSHMEM_INIT_CHK_RET_NULL ();
+  nsfw_read_lock (nsfw_get_glb_lock ());
+
+  for (icnt = 0; icnt < NSFW_NSHMEM_ZONE_MAX; icnt++)
+    {
+      mz = &g_nshmem_internal_cfg->amemzone[icnt];
+
+      if (mz->addr != NULL
+          && !strncmp (pname->aname, mz->aname, NSFW_MEM_NAME_LENTH))
+        {
+          nsfw_read_unlock (nsfw_get_glb_lock ());
+          return mz->addr;
+        }
+    }
+
+  nsfw_read_unlock (nsfw_get_glb_lock ());
+  return NULL;
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_nshmem_release
+*   Description  : free a block memory
+*   Input        : nsfw_mem_name* pname
+*   Output       : None
+*   Return Value : i32
+*   Calls        :
+*   Called By    :
+*
+*****************************************************************************/
+i32
+nsfw_nshmem_release (nsfw_mem_name * pname)
+{
+  int icnt = 0;
+  nsfw_nshmem_mzone *mz = NULL;
+
+  NSFW_NAME_LENCHECK_RET (pname->aname, "nshmem release");
+  NSFW_NSHMEM_INIT_CHK_RET ();
+  nsfw_read_lock (nsfw_get_glb_lock ());
+
+  for (icnt = 0; icnt < NSFW_NSHMEM_ZONE_MAX; icnt++)
+    {
+      mz = &g_nshmem_internal_cfg->amemzone[icnt];
+
+      if (mz->addr != NULL
+          && !strncmp (pname->aname, mz->aname, NSFW_MEM_NAME_LENTH))
+        {
+          nsfw_nshmem_free_zone (mz);
+          nsfw_read_unlock (nsfw_get_glb_lock ());
+          return NSFW_MEM_OK;
+        }
+    }
+
+  nsfw_read_unlock (nsfw_get_glb_lock ());
+  return NSFW_MEM_OK;
+
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_nshmem_spcreate
+*   Description  : create a memory pool by ring
+*   Input        : nsfw_mem_sppool* pmpinfo
+*   Output       : None
+*   Return Value : mring_handle
+*   Calls        :
+*   Called By    :
+*****************************************************************************/
+mring_handle
+nsfw_nshmem_spcreate (nsfw_mem_sppool * pmpinfo)
+{
+  size_t len = 0;
+  unsigned int usnum = common_mem_align32pow2 (pmpinfo->usnum + 1);
+  unsigned int uselt_size = pmpinfo->useltsize;
+  struct nsfw_mem_ring *pringhead = NULL;
+  unsigned int uscnt = 0;
+  char *pmz = NULL;
+  NSFW_NAME_LENCHECK_RET_NULL (pmpinfo->stname.aname, "nshmem sp create");
+  NSFW_NSHMEM_INIT_CHK_RET_NULL ();
+
+  len =
+    sizeof (struct nsfw_mem_ring) +
+    (size_t) usnum *sizeof (union RingData_U) + (size_t) usnum *uselt_size;
+  pringhead =
+    (struct nsfw_mem_ring *) nsfw_nshmem_reserv_safe (pmpinfo->stname.aname,
+                                                      len);
+
+  if (!pringhead)
+    {
+      NSCOMM_LOGERR ("nshmem sp create mzone reserv fail");
+      return NULL;
+    }
+
+  nsfw_mem_ring_init (pringhead, usnum, pringhead, NSFW_NSHMEM,
+                      pmpinfo->enmptype);
+  pmz =
+    ((char *) pringhead + sizeof (struct nsfw_mem_ring) +
+     usnum * sizeof (union RingData_U));
+
+  for (uscnt = 0; uscnt < usnum; uscnt++)
+    {
+      if (0 ==
+          g_ring_ops_arry[pringhead->memtype][pringhead->
+                                              ringflag].ring_ops_enqueue
+          (pringhead, (void *) pmz))
+        {
+          NSCOMM_LOGERR ("nsfw_nshmem_ringenqueue enque fail] uscnt=%u",
+                         uscnt);
+        }
+
+      pmz = pmz + uselt_size;
+    }
+
+  return pringhead;
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_nshmem_sp_lookup
+*   Description  : look up a sppool memory
+*   Input        : nsfw_mem_name* pname
+*   Output       : None
+*   Return Value : mring_handle
+*   Calls        :
+*   Called By    :
+*****************************************************************************/
+mring_handle
+nsfw_nshmem_sp_lookup (nsfw_mem_name * pname)
+{
+  return nsfw_nshmem_lookup (pname);
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_nshmem_sprelease
+*   Description  : release a sp pool
+*   Input        : nsfw_mem_name* pname
+*   Output       : None
+*   Return Value : i32
+*   Calls        :
+*   Called By    :
+*
+*****************************************************************************/
+i32
+nsfw_nshmem_sprelease (nsfw_mem_name * pname)
+{
+  NSFW_NAME_LENCHECK_RET (pname->aname, "nshmem sp mempool release");
+  NSFW_NSHMEM_INIT_CHK_RET ();
+  return nsfw_nshmem_release (pname);
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_nshmem_ringcreate
+*   Description  : create a ring
+*   Input        : nsfw_mem_mring* pringinfo
+*   Output       : None
+*   Return Value : mring_handle
+*   Calls        :
+*   Called By    :
+*
+*****************************************************************************/
+mring_handle
+nsfw_nshmem_ringcreate (nsfw_mem_mring * pringinfo)
+{
+  size_t len = 0;
+  unsigned int usnum = common_mem_align32pow2 (pringinfo->usnum + 1);
+  struct nsfw_mem_ring *pringhead = NULL;
+  NSFW_NAME_LENCHECK_RET_NULL (pringinfo->stname.aname, "nshmem ring create");
+  NSFW_NSHMEM_INIT_CHK_RET_NULL ();
+
+  len = sizeof (struct nsfw_mem_ring) + usnum * sizeof (union RingData_U);
+  pringhead =
+    (struct nsfw_mem_ring *) nsfw_nshmem_reserv_safe (pringinfo->stname.aname,
+                                                      len);
+
+  if (!pringhead)
+    {
+      NSCOMM_LOGERR ("nshmem ring create mzone reserv fail");
+      return NULL;
+    }
+
+  nsfw_mem_ring_init (pringhead, usnum, (void *) pringhead, NSFW_NSHMEM,
+                      pringinfo->enmptype);
+  return pringhead;
+
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_nshmem_ringrelease
+*   Description  : release a nsh ring memory
+*   Input        : nsfw_mem_name* pname
+*   Output       : None
+*   Return Value : i32
+*   Calls        :
+*   Called By    :
+*
+*****************************************************************************/
+i32
+nsfw_nshmem_ringrelease (nsfw_mem_name * pname)
+{
+  NSFW_NAME_LENCHECK_RET (pname->aname, "nshmem ring mempool release");
+  NSFW_NSHMEM_INIT_CHK_RET ();
+  return nsfw_nshmem_release (pname);
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_nshmem_sppool_statics
+*   Description  : static the memory size of sppool
+*   Input        : mring_handle sppool
+*   Output       : None
+*   Return Value : ssize_t
+*   Calls        :
+*   Called By    :
+*
+*****************************************************************************/
+ssize_t
+nsfw_nshmem_sppool_statics (mring_handle sppool)
+{
+  struct nsfw_mem_ring *phead = (struct nsfw_mem_ring *) sppool;
+
+  return sizeof (struct nsfw_mem_ring) +
+    (ssize_t) phead->size * sizeof (union RingData_U) +
+    (ssize_t) phead->size * phead->eltsize;
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_nshmem_ring_statics
+*   Description  : static the memory size of ring
+*   Input        : mring_handle handle
+*   Output       : None
+*   Return Value : ssize_t
+*   Calls        :
+*   Called By    :
+*
+*****************************************************************************/
+ssize_t
+nsfw_nshmem_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);
+}
+
+/*****************************************************************************
+*   Prototype    : nsfw_nshmem_stactic
+*   Description  : static the memory size according to mem type
+*   Input        : void* handle
+*                  nsfw_mem_struct_type type
+*   Output       : None
+*   Return Value : ssize_t
+*   Calls        :
+*   Called By    :
+*
+*****************************************************************************/
+ssize_t
+nsfw_nshmem_stactic (void *handle, nsfw_mem_struct_type type)
+{
+  switch (type)
+    {
+    case NSFW_MEM_MBUF:
+      return -1;
+    case NSFW_MEM_SPOOL:
+      return nsfw_nshmem_sppool_statics (handle);
+    case NSFW_MEM_RING:
+      return nsfw_nshmem_ring_statics (handle);
+    default:
+      break;
+    }
+  return -1;
+}
diff --git a/src/framework/common/mem_mgr/nsfw_nshmem/nsfw_nshmem_mng.h b/src/framework/common/mem_mgr/nsfw_nshmem/nsfw_nshmem_mng.h
new file mode 100644
index 0000000..3f5b1b9
--- /dev/null
+++ b/src/framework/common/mem_mgr/nsfw_nshmem/nsfw_nshmem_mng.h
@@ -0,0 +1,70 @@
+/*
+*
+* 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.
+*/
+
+#ifndef _NSFW_NSHMEM_MNG_H_
+#define _NSFW_NSHMEM_MNG_H_
+
+#include "generic/common_mem_rwlock.h"
+
+#include "common_func.h"
+
+#define NSFW_NSHMEM_ZONE_MAX    2560
+
+typedef struct
+{
+  i8 aname[NSFW_MEM_NAME_LENTH];
+  void *addr;
+  int lenth;
+} nsfw_nshmem_mzone;
+
+typedef struct
+{
+  nsfw_nshmem_mzone amemzone[NSFW_NSHMEM_ZONE_MAX];
+  common_mem_rwlock_t mlock;
+} nsfw_nshmem_cfg;
+
+/*
+ * no share memory module init
+ */
+i32 nsfw_nshmem_init (nsfw_mem_para * para);
+
+/*
+ * no share memory moudle destory
+ */
+void nsfw_nshmem_destory (void);
+
+/*
+ * create a no shared memory
+ */
+mzone_handle nsfw_nshmem_create (nsfw_mem_zone * pinfo);
+
+mzone_handle nsfw_nshmem_lookup (nsfw_mem_name * pname);
+
+i32 nsfw_nshmem_release (nsfw_mem_name * pname);
+
+mring_handle nsfw_nshmem_spcreate (nsfw_mem_sppool * pmpinfo);
+
+i32 nsfw_nshmem_sprelease (nsfw_mem_name * pname);
+
+mring_handle nsfw_nshmem_sp_lookup (nsfw_mem_name * pname);
+
+mring_handle nsfw_nshmem_ringcreate (nsfw_mem_mring * pringinfo);
+
+i32 nsfw_nshmem_ringrelease (nsfw_mem_name * pname);
+
+ssize_t nsfw_nshmem_stactic (void *handle, nsfw_mem_struct_type type);
+
+#endif
diff --git a/src/framework/common/mem_mgr/nsfw_nshmem/nsfw_nshmem_ring.c b/src/framework/common/mem_mgr/nsfw_nshmem/nsfw_nshmem_ring.c
new file mode 100644
index 0000000..64e7d57
--- /dev/null
+++ b/src/framework/common/mem_mgr/nsfw_nshmem/nsfw_nshmem_ring.c
@@ -0,0 +1,436 @@
+/*
+*
+* 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 <string.h>
+#include <sched.h>
+#include "nstack_securec.h"
+
+#include "nsfw_mem_desc.h"
+#include "nsfw_nshmem_ring.h"
+#include "nsfw_ring_fun.h"
+#include "common_func.h"
+
+/*copy the data to obj*/
+NSTACK_STATIC inline void
+nsfw_nshmem_ring_obj_copy (struct nsfw_mem_ring *r, uint32_t cons_head,
+                           void **obj_table, unsigned n)
+{
+  uint32_t idx = cons_head & r->mask;
+  unsigned i = 0;
+  const uint32_t size = r->size;
+
+  if (likely (idx + n < size))
+    {
+      for (i = 0; i < (n & (~(unsigned) 0x3)); i += 4, idx += 4)
+        {
+          obj_table[i] = (void *) r->ring[idx].data_l;
+          obj_table[i + 1] = (void *) r->ring[idx + 1].data_l;
+          obj_table[i + 2] = (void *) r->ring[idx + 2].data_l;
+          obj_table[i + 3] = (void *) r->ring[idx + 3].data_l;
+        }
+      switch (n & 0x3)
+        {
+        case 3:
+          obj_table[i++] = (void *) r->ring[idx++].data_l;
+
+        case 2:
+          obj_table[i++] = (void *) r->ring[idx++].data_l;
+
+        case 1:
+          obj_table[i++] = (void *) r->ring[idx++].data_l;
+        }
+    }
+  else
+    {
+      for (i = 0; idx < size; i++, idx++)
+        {
+          obj_table[i] = (void *) r->ring[idx].data_l;
+        }
+
+      for (idx = 0; i < n; i++, idx++)
+        {
+          obj_table[i] = (void *) r->ring[idx].data_l;
+        }
+    }
+}
+
+/*fork recover*/
+NSTACK_STATIC inline void
+nsfw_nshmem_enqueue_fork_recov (struct nsfw_mem_ring *r)
+{
+  u32_t pidflag = 0;
+  u32_t curpid = get_sys_pid ();
+  int success = 0;
+  /*if pid is not the same, maybe mult thread fork happen */
+  pidflag = r->prodhflag;
+
+  if (unlikely (pidflag != curpid))
+    {
+      success = common_mem_atomic32_cmpset (&r->prodhflag, pidflag, curpid);
+
+      if (unlikely (success != 0))
+        {
+          /*recover it */
+          if (r->prod.tail != r->prod.head)
+            {
+              r->prod.head = r->prod.tail;
+            }
+
+          r->prodtflag = curpid;
+        }
+    }
+
+  return;
+}
+
+NSTACK_STATIC inline void
+nsfw_nshmem_dequeue_fork_recov (struct nsfw_mem_ring *r)
+{
+  u32_t pidflag = 0;
+  u32_t curpid = get_sys_pid ();
+  int success = 0;
+  /*if pid is not the same, maybe mult thread fork happen */
+  pidflag = r->conshflag;
+
+  if (unlikely (pidflag != curpid))
+    {
+      success = common_mem_atomic32_cmpset (&r->conshflag, pidflag, curpid);
+
+      if (unlikely (success != 0))
+        {
+          /*recover it */
+          if (r->cons.tail != r->cons.head)
+            {
+              r->cons.head = r->cons.tail;
+            }
+
+          r->constflag = curpid;
+        }
+    }
+
+  return;
+}
+
+/*
+this is a  multi thread/process enqueue function, please pay attention to the bellow point
+1. while Enqueue corrupt,  we may lose one element; because no one to add the Head
+*/
+int
+nsfw_nshmem_ring_mp_enqueue (struct nsfw_mem_ring *mem_ring, void *obj_table)
+{
+  uint32_t prod_head, prod_next;
+  uint32_t cons_tail, free_entries;
+  int success;
+  unsigned rep = 0;
+  uint32_t mask = mem_ring->mask;
+  uint32_t size = mem_ring->size;
+  uint32_t n = 1;
+
+  /* move prod.head atomically */
+  do
+    {
+
+      prod_head = mem_ring->prod.head;
+      cons_tail = mem_ring->cons.tail;
+      /* The subtraction is done between two unsigned 32bits value
+       * (the result is always modulo 32 bits even if we have
+       * prod_head > cons_tail). So 'free_entries' is always between 0
+       * and size(ring)-1. */
+      free_entries = (size + cons_tail - prod_head);
+
+      /* check that we have enough room in ring */
+      if (unlikely (n > free_entries))
+        {
+          return 0;
+          /* Below code is commented currenlty as its a dead code. */
+        }
+
+      /*if pid is not the same, maybe mult thread fork happen */
+      nsfw_nshmem_enqueue_fork_recov (mem_ring);
+
+      while (unlikely
+             ((mem_ring->prod.tail != mem_ring->prod.head)
+              || (mem_ring->prodtflag != mem_ring->prodhflag)))
+        {
+          common_mem_pause ();
+        }
+
+      prod_next = prod_head + n;
+      success =
+        common_mem_atomic32_cmpset (&mem_ring->prod.head, prod_head,
+                                    prod_next);
+    }
+  while (unlikely (success == 0));
+
+  mem_ring->ring[prod_head & mask].data_l = (u64) obj_table;
+
+  /*
+   * If there are other enqueues in progress that preceded us,
+   * we need to wait for them to complete
+   */
+  while (unlikely (mem_ring->prod.tail != prod_head))
+    {
+      common_mem_pause ();
+
+      /* Set COMMON_RING_PAUSE_REP_COUNT to avoid spin too long waiting
+       * for other thread finish. It gives pre-empted thread a chance
+       * to proceed and finish with ring dequeue operation. */
+      /* check the queue can be operate */
+      if (++rep == 5)
+        {
+          rep = 0;
+          (void) sched_yield ();
+        }
+    }
+
+  mem_ring->prod.tail = prod_next;
+  return (int) n;
+}
+
+/*
+   this is a  single thread/process enqueue function
+ */
+int
+nsfw_nshmem_ring_sp_enqueue (struct nsfw_mem_ring *r, void *obj_table)
+{
+  uint32_t prod_head, cons_tail;
+  uint32_t prod_next, free_entries;
+  uint32_t mask = r->mask;
+  uint32_t n = 1;
+  uint32_t size = r->size;
+
+  prod_head = r->prod.head;
+  cons_tail = r->cons.tail;
+  /* The subtraction is done between two unsigned 32bits value
+   * (the result is always modulo 32 bits even if we have
+   * prod_head > cons_tail). So 'free_entries' is always between 0
+   * and size(ring)-1. */
+  free_entries = size + cons_tail - prod_head;
+
+  /* check that we have enough room in ring */
+  if (unlikely (n > free_entries))
+    {
+      return 0;
+    }
+
+  nsfw_nshmem_enqueue_fork_recov (r);
+
+  prod_next = prod_head + n;
+  r->prod.head = prod_next;
+
+  r->ring[prod_head & mask].data_l = (u64) obj_table;
+
+  r->prod.tail = prod_next;
+  return (int) n;
+}
+
+/*
+   this is enhanced mc_ring_dequeue, support dequeue multi element one time.
+*/
+int
+nsfw_nshmem_ring_mc_dequeuev (struct nsfw_mem_ring *r, void **obj_table,
+                              unsigned int n)
+{
+  uint32_t cons_head, prod_tail;
+  uint32_t cons_next, entries;
+  int success;
+  unsigned rep = 0;
+  uint32_t num = n;
+
+  /* Avoid the unnecessary cmpset operation below, which is also
+   * potentially harmful when n equals 0. */
+  if (unlikely (num == 0))
+    {
+      return 0;
+    }
+
+  nsfw_nshmem_dequeue_fork_recov (r);
+
+  /* move cons.head atomically */
+  do
+    {
+      num = n;
+      cons_head = r->cons.head;
+      prod_tail = r->prod.tail;
+      /* The subtraction is done between two unsigned 32bits value
+       * (the result is always modulo 32 bits even if we have
+       * cons_head > prod_tail). So 'entries' is always between 0
+       * and size(ring)-1. */
+      entries = (prod_tail - cons_head);
+
+      /* Set the actual entries for dequeue */
+      if (unlikely (num > entries))
+        {
+          if (likely (entries > 0))
+            {
+              num = entries;
+            }
+          else
+            {
+              return 0;
+            }
+        }
+
+      /* check the queue can be operate */
+      while (unlikely
+             ((r->cons.tail != r->cons.head)
+              || (r->conshflag != r->constflag)))
+        {
+          common_mem_pause ();
+        }
+
+      cons_next = cons_head + num;
+
+      success =
+        common_mem_atomic32_cmpset (&r->cons.head, cons_head, cons_next);
+    }
+  while (unlikely (success == 0));
+
+  nsfw_nshmem_ring_obj_copy (r, cons_head, obj_table, num);
+
+  /*
+   * If there are other dequeues in progress that preceded us,
+   * we need to wait for them to complete
+   */
+  while (unlikely (r->cons.tail != cons_head))
+    {
+      common_mem_pause ();
+
+      /* Set COMMON_RING_PAUSE_REP_COUNT to avoid spin too long waiting
+       * for other thread finish. It gives pre-empted thread a chance
+       * to proceed and finish with ring dequeue operation. */
+      /* check the queue can be operate */
+      if (++rep == 5)
+        {
+          rep = 0;
+          (void) sched_yield ();
+        }
+    }
+
+  r->cons.tail = cons_next;
+
+  return (int) num;
+}
+
+/*this is a  multi thread/process dequeue function, please pay attention to the bellow point
+1. while dequeue corrupt,  the tail no one added, may multy the try times.
+*/
+int
+nsfw_nshmem_ring_mc_dequeue (struct nsfw_mem_ring *ring, void **box)
+{
+  return nsfw_nshmem_ring_mc_dequeuev (ring, box, 1);
+}
+
+/*
+   this is a single thread/process dequeue function
+*/
+int
+nsfw_nshmem_ring_sc_dequeuev (struct nsfw_mem_ring *r, void **obj_table,
+                              unsigned int n)
+{
+  uint32_t cons_head, prod_tail;
+  uint32_t cons_next, entries;
+  uint32_t inum = n;
+  cons_head = r->cons.head;
+  prod_tail = r->prod.tail;
+  /* The subtraction is done between two unsigned 32bits value
+   * (the result is always modulo 32 bits even if we have
+   * cons_head > prod_tail). So 'entries' is always between 0
+   * and size(ring)-1. */
+  entries = prod_tail - cons_head;
+
+  if (unlikely (inum > entries))
+    {
+      if (likely (entries > 0))
+        {
+          inum = entries;
+        }
+      else
+        {
+          return 0;
+        }
+    }
+
+  nsfw_nshmem_dequeue_fork_recov (r);
+
+  cons_next = cons_head + inum;
+  r->cons.head = cons_next;
+
+  nsfw_nshmem_ring_obj_copy (r, cons_head, obj_table, inum);
+
+  r->cons.tail = cons_next;
+  return (int) inum;
+}
+
+/*
+   this is enhanced mc_ring_dequeue, support dequeue multi element one time.
+*/
+int
+nsfw_nshmem_ring_sc_dequeue (struct nsfw_mem_ring *ring, void **box)
+{
+  return nsfw_nshmem_ring_sc_dequeuev (ring, box, 1);
+}
+
+/*stack just using one thread, for performance using que not support multi thread*/
+int
+nsfw_nshmem_ring_singlethread_enqueue (struct nsfw_mem_ring *ring, void *box)
+{
+  u32 head = 0;
+
+  /*if queue is full, just return 0 */
+  if (unlikely (ring->prod.head >= (ring->size + ring->cons.tail)))
+    {
+      return 0;
+    }
+
+  head = ring->prod.head;
+  ring->ring[head & ring->mask].data_l = (u64) box;
+  ring->prod.head++;
+  return 1;
+}
+
+/*stack just using one thread, for performance using que not support multi thread*/
+int
+nsfw_nshmem_ring_singlethread_dequeue (struct nsfw_mem_ring *ring, void **box)
+{
+  return nsfw_nshmem_ring_singlethread_dequeuev (ring, box, 1);
+}
+
+/*stack just using one thread, for performance using que not support multi thread*/
+int
+nsfw_nshmem_ring_singlethread_dequeuev (struct nsfw_mem_ring *ring,
+                                        void **box, unsigned int n)
+{
+  u32 tail = 0;
+  u32 num = 0;
+
+  while (num < n)
+    {
+      tail = ring->cons.tail;
+
+      /* if all entries are dequed return 0 */
+      if (unlikely (ring->prod.head == ring->cons.tail))
+        {
+          return num;
+        }
+
+      box[num] = (void *) ring->ring[tail & ring->mask].data_l;
+      ring->cons.tail++;
+      num++;
+    }
+
+  return num;
+}
diff --git a/src/framework/common/mem_mgr/nsfw_nshmem/nsfw_nshmem_ring.h b/src/framework/common/mem_mgr/nsfw_nshmem/nsfw_nshmem_ring.h
new file mode 100644
index 0000000..93a4d4a
--- /dev/null
+++ b/src/framework/common/mem_mgr/nsfw_nshmem/nsfw_nshmem_ring.h
@@ -0,0 +1,37 @@
+/*
+*
+* 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.
+*/
+
+#ifndef _NSFW_NSHMEM_RING_H_
+#define _NSFW_NSHMEM_RING_H_
+
+#include <stdint.h>
+
+int nsfw_nshmem_ring_mp_enqueue (struct nsfw_mem_ring *ring, void *box);
+int nsfw_nshmem_ring_sp_enqueue (struct nsfw_mem_ring *ring, void *box);
+int nsfw_nshmem_ring_mc_dequeue (struct nsfw_mem_ring *ring, void **box);
+int nsfw_nshmem_ring_mc_dequeuev (struct nsfw_mem_ring *ring, void **box,
+                                  unsigned int n);
+int nsfw_nshmem_ring_sc_dequeue (struct nsfw_mem_ring *ring, void **box);
+int nsfw_nshmem_ring_sc_dequeuev (struct nsfw_mem_ring *ring, void **box,
+                                  unsigned int n);
+int nsfw_nshmem_ring_singlethread_enqueue (struct nsfw_mem_ring *ring,
+                                           void *box);
+int nsfw_nshmem_ring_singlethread_dequeue (struct nsfw_mem_ring *ring,
+                                           void **box);
+int nsfw_nshmem_ring_singlethread_dequeuev (struct nsfw_mem_ring *ring,
+                                            void **box, unsigned int n);
+
+#endif /*_NSFW_NSHMEM_RING_H_*/
diff --git a/src/framework/common/mem_mgr/nsfw_res_mgr.c b/src/framework/common/mem_mgr/nsfw_res_mgr.c
new file mode 100644
index 0000000..2f676c9
--- /dev/null
+++ b/src/framework/common/mem_mgr/nsfw_res_mgr.c
@@ -0,0 +1,429 @@
+/*
+*
+* 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 header files                    *
+ *----------------------------------------------*/
+
+/*==============================================*
+ *      constants or macros define              *
+ *----------------------------------------------*/
+
+/*==============================================*
+ *      project-wide global variables           *
+ *----------------------------------------------*/
+
+/*==============================================*
+ *      routines' or functions' implementations *
+ *----------------------------------------------*/
+
+#include <stdlib.h>
+#include "types.h"
+#include "nstack_securec.h"
+#include "nsfw_init.h"
+#include "common_mem_mbuf.h"
+
+#include "nstack_log.h"
+#include "nsfw_maintain_api.h"
+
+#include "nsfw_mem_api.h"
+#include "nsfw_fd_timer_api.h"
+#include "nsfw_ring_data.h"
+
+#include "common_func.h"
+
+#ifdef __cplusplus
+/* *INDENT-OFF* */
+extern "C"{
+/* *INDENT-ON* */
+#endif /* __cplusplus */
+
+nsfw_res_mgr_item_cfg g_all_res_can[NSFW_MAX_RES_SCAN_COUNT];
+
+#define NSFW_RES_SCAN_TVLAUE_DEF 60
+#define NSFW_RES_SCAN_TVLAUE (g_scan_cfg.scan_tvalue)
+
+typedef struct _nsfw_res_scan_init_cfg
+{
+  nsfw_timer_info *scan_timer;
+  u16 scan_tvalue;
+} nsfw_res_scan_init_cfg;
+nsfw_res_scan_init_cfg g_scan_cfg;
+
+u8
+nsfw_res_mgr_reg (nsfw_res_scn_cfg * cfg)
+{
+  if (NULL == cfg)
+    {
+      NSFW_LOGERR ("argv err!");
+      return FALSE;
+    }
+
+  u32 i;
+  for (i = 0; i < NSFW_MAX_RES_SCAN_COUNT; i++)
+    {
+      if ((NULL == g_all_res_can[i].scn_cfg.free_fun)
+          &&
+          (__sync_bool_compare_and_swap
+           (&g_all_res_can[i].scn_cfg.free_fun, 0, cfg->free_fun)))
+        {
+          g_all_res_can[i].scn_cfg = *cfg;
+          NSFW_LOGINF ("reg res_mgr fun suc]fun=%p,data=%p", cfg->free_fun,
+                       cfg->data);
+          return TRUE;
+        }
+    }
+
+  NSFW_LOGERR
+    ("reg]type=%u,per=%u,chk=%u,cyc=%u,total=%u,size=%u,offset=%u,fun=%p,data=%p",
+     cfg->type, cfg->force_free_percent, cfg->force_free_chk_num,
+     cfg->num_per_cyc, cfg->total_num, cfg->elm_size, cfg->res_mem_offset,
+     cfg->res_mem_offset, cfg->free_fun, cfg->data);
+  return FALSE;
+}
+
+static inline u32
+nsfw_get_alloc_count (u32 head, u32 tail)
+{
+  if (head >= tail)
+    {
+      return head - tail;
+    }
+
+  return head + (0xFFFFFFFF - tail);
+}
+
+int
+nsfw_res_sp_item_chk (void *data, void *argv)
+{
+  nsfw_res_mgr_item_cfg *res_scn_item = (nsfw_res_mgr_item_cfg *) argv;
+  nsfw_res_scn_cfg *scn_cfg = &res_scn_item->scn_cfg;
+  char *elm = (char *) data;
+
+  if (NULL == scn_cfg || NULL == elm)
+    {
+      return FALSE;
+    }
+
+  nsfw_res *res_item = NULL;
+  res_item = (nsfw_res *) (elm + scn_cfg->res_mem_offset);
+  if (0 == res_item->chk_count)
+    {
+      res_item->data = res_scn_item->cons_head;
+    }
+  res_item->chk_count++;
+
+  if (res_item->chk_count < scn_cfg->force_free_chk_num)
+    {
+      return FALSE;
+    }
+
+  if (res_scn_item->free_percent > scn_cfg->force_free_percent)
+    {
+      return FALSE;
+    }
+
+  if (scn_cfg->total_num * scn_cfg->alloc_speed_factor >
+      nsfw_get_alloc_count (res_scn_item->cons_head, res_item->data))
+    {
+      return FALSE;
+    }
+
+  if (NULL == scn_cfg->free_fun)
+    {
+      return FALSE;
+    }
+
+  if (TRUE == scn_cfg->free_fun ((void *) elm))
+    {
+      res_scn_item->force_count++;
+    }
+
+  res_item->chk_count = 0;
+  return TRUE;
+}
+
+int
+nsfw_res_flash_data (nsfw_res_mgr_item_cfg * res_scn_item)
+{
+  nsfw_res_scn_cfg *scn_cfg = &res_scn_item->scn_cfg;
+
+  u32 cur_head = 0;
+  u32 cur_tail = 0;
+  u32 elm_num = 0;
+  u32 free_count = 0;
+
+  switch (scn_cfg->type)
+    {
+    case NSFW_RES_SCAN_MBUF:
+      {
+        struct common_mem_ring *ring =
+          (struct common_mem_ring *) scn_cfg->mgr_ring;
+        struct common_mem_mempool *mp =
+          (struct common_mem_mempool *) scn_cfg->data;
+        if (NULL == ring)
+          {
+            ring = mp->ring;
+            if (NULL == ring)
+              return FALSE;
+          }
+        cur_head = ring->prod.head;
+        cur_tail = ring->cons.head;
+        elm_num = mp->size;
+      }
+      break;
+    case NSFW_RES_SCAN_SPOOL:
+      {
+        struct nsfw_mem_ring *mem_ring =
+          (struct nsfw_mem_ring *) scn_cfg->mgr_ring;
+        if (NULL == mem_ring)
+          {
+            mem_ring = (struct nsfw_mem_ring *) scn_cfg->data;
+            if (NULL == mem_ring)
+              return FALSE;
+          }
+
+        cur_head = mem_ring->prod.head;
+        cur_tail = mem_ring->cons.tail;
+        elm_num = mem_ring->size;
+      }
+      break;
+    case NSFW_RES_SCAN_ARRAY:
+      {
+        struct nsfw_mem_ring *mem_ring =
+          (struct nsfw_mem_ring *) scn_cfg->mgr_ring;
+        if (NULL == mem_ring)
+          {
+            return FALSE;
+          }
+
+        cur_head = mem_ring->prod.head;
+        cur_tail = mem_ring->cons.tail;
+        elm_num = scn_cfg->total_num;
+      }
+      break;
+    default:
+      return FALSE;
+    }
+
+  free_count = nsfw_get_alloc_count (cur_head, cur_tail);
+
+  res_scn_item->cons_head = cur_head;
+  res_scn_item->prod_head = cur_tail;
+  if (0 != elm_num)
+    {
+      res_scn_item->free_percent = free_count * 100 / elm_num;
+    }
+  else
+    {
+      res_scn_item->free_percent = 100;
+    }
+
+  scn_cfg->total_num = elm_num;
+  return TRUE;
+}
+
+void
+nsfw_res_scan_mem (nsfw_res_mgr_item_cfg * res_scn_item)
+{
+  if (NULL == res_scn_item)
+    {
+      return;
+    }
+
+  nsfw_res_scn_cfg *scn_cfg = &res_scn_item->scn_cfg;
+  if (NULL == scn_cfg->data)
+    {
+      return;
+    }
+
+  u32 start = res_scn_item->last_scn_idx;
+  u32 end = start + scn_cfg->num_per_cyc;
+  int res_chk_number = 0;
+  if (NSFW_RES_SCAN_SPOOL == scn_cfg->type)
+    {
+      res_chk_number =
+        nsfw_mem_sp_iterator (scn_cfg->data, start, end,
+                              nsfw_res_sp_item_chk, (void *) res_scn_item);
+    }
+  else
+    {
+      res_chk_number =
+        nsfw_mem_mbuf_iterator (scn_cfg->data, start, end,
+                                nsfw_res_sp_item_chk, (void *) res_scn_item);
+    }
+
+  if (0 == res_chk_number)
+    {
+      res_scn_item->last_scn_idx = 0;
+      start = res_scn_item->last_scn_idx;
+      end = start + scn_cfg->num_per_cyc;
+      if (NSFW_RES_SCAN_SPOOL == scn_cfg->type)
+        {
+          res_chk_number =
+            nsfw_mem_sp_iterator (scn_cfg->data, start, end,
+                                  nsfw_res_sp_item_chk,
+                                  (void *) res_scn_item);
+        }
+      else
+        {
+          res_chk_number =
+            nsfw_mem_mbuf_iterator (scn_cfg->data, start, end,
+                                    nsfw_res_sp_item_chk,
+                                    (void *) res_scn_item);
+        }
+    }
+
+  if (res_chk_number + start < end)
+    {
+      res_scn_item->last_scn_idx = 0;
+    }
+  else
+    {
+      res_scn_item->last_scn_idx += res_chk_number;
+    }
+
+  return;
+}
+
+void
+nsfw_res_scan_array (nsfw_res_mgr_item_cfg * res_scn_item)
+{
+  if (NULL == res_scn_item)
+    {
+      return;
+    }
+
+  nsfw_res_scn_cfg *scn_cfg = &res_scn_item->scn_cfg;
+  if (NULL == scn_cfg->data)
+    {
+      return;
+    }
+
+  u32 i;
+  char *elm =
+    (char *) scn_cfg->data + (res_scn_item->last_scn_idx * scn_cfg->elm_size);
+  for (i = res_scn_item->last_scn_idx; i < scn_cfg->total_num; i++)
+    {
+      if (i >= res_scn_item->last_scn_idx + scn_cfg->num_per_cyc)
+        {
+          break;
+        }
+
+      if (TRUE == nsfw_res_sp_item_chk (elm, (void *) res_scn_item))
+        {
+          NSFW_LOGINF ("force free item]data=%p,cfg=%p", elm, res_scn_item);
+        }
+
+      elm += scn_cfg->elm_size;
+    }
+
+  if (i >= scn_cfg->total_num)
+    {
+      res_scn_item->last_scn_idx = 0;
+    }
+  else
+    {
+      res_scn_item->last_scn_idx = i;
+    }
+
+  return;
+}
+
+void
+nsfw_res_scan_proc (nsfw_res_mgr_item_cfg * res_scn_item)
+{
+  (void) nsfw_res_flash_data (res_scn_item);
+  switch (res_scn_item->scn_cfg.type)
+    {
+    case NSFW_RES_SCAN_ARRAY:
+      nsfw_res_scan_array (res_scn_item);
+      break;
+    case NSFW_RES_SCAN_SPOOL:
+    case NSFW_RES_SCAN_MBUF:
+      nsfw_res_scan_mem (res_scn_item);
+      break;
+    default:
+      break;
+    }
+}
+
+int
+nsfw_res_scan_all (u32 timer_type, void *data)
+{
+  NSFW_LOGDBG ("scan start!");
+  struct timespec time_left = { NSFW_RES_SCAN_TVLAUE, 0 };
+  g_scan_cfg.scan_timer =
+    nsfw_timer_reg_timer (0, NULL, nsfw_res_scan_all, time_left);
+
+  if (g_hbt_switch)
+    {
+      return TRUE;
+    }
+
+  int i;
+  for (i = 0; i < NSFW_MAX_RES_SCAN_COUNT; i++)
+    {
+      /*last fun */
+      if (NULL == g_all_res_can[i].scn_cfg.data)
+        {
+          break;
+        }
+
+      nsfw_res_scan_proc (&g_all_res_can[i]);
+    }
+
+  return TRUE;
+}
+
+static int nsfw_resmgr_module_init (void *param);
+static int
+nsfw_resmgr_module_init (void *param)
+{
+  u8 proc_type = (u8) ((long long) param);
+  NSFW_LOGINF ("res mgr module init]type=%u", proc_type);
+  g_scan_cfg.scan_tvalue = NSFW_RES_SCAN_TVLAUE_DEF;
+  switch (proc_type)
+    {
+    case NSFW_PROC_MAIN:
+      {
+        struct timespec time_left = { NSFW_RES_SCAN_TVLAUE, 0 };
+        g_scan_cfg.scan_timer =
+          nsfw_timer_reg_timer (0, NULL, nsfw_res_scan_all, time_left);
+        return 0;
+      }
+    default:
+      if (proc_type < NSFW_PROC_MAX)
+        {
+          break;
+        }
+      return -1;
+    }
+
+  return 0;
+}
+
+/* *INDENT-OFF* */
+NSFW_MODULE_NAME(NSFW_RES_MGR_MODULE)
+NSFW_MODULE_PRIORITY(99)
+NSFW_MODULE_INIT(nsfw_resmgr_module_init)
+/* *INDENT-ON* */
+
+#ifdef __cplusplus
+/* *INDENT-OFF* */
+}
+/* *INDENT-ON* */
+#endif /* __cplusplus */
diff --git a/src/framework/common/mem_mgr/nsfw_shmem/nsfw_rshmem_mng.c b/src/framework/common/mem_mgr/nsfw_shmem/nsfw_rshmem_mng.c
new file mode 100644
index 0000000..dc3400d
--- /dev/null
+++ b/src/framework/common/mem_mgr/nsfw_shmem/nsfw_rshmem_mng.c
@@ -0,0 +1,987 @@
+/*
+*
+* 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 <stdint.h>
+#include "nstack_securec.h"
+#include "nstack_log.h"
+#include "nsfw_ring_fun.h"
+#include "nsfw_shmem_ring.h"
+#include "nsfw_shmem_mng.h"
+#include "common_mem_buf.h"
+#include "common_mem_common.h"
+
+#include "common_func.h"
+
+/*get the base address of msg data */
+#define NSFW_SHMEM_GET_DATA(pmsg, type) (type *)&((pmsg)->aidata[0])
+
+/*if input point is nun, just return null*/
+#define NSFW_POINT_CHK_RET_NULL(p, desc) \
+    if (NULL == (p))  \
+    {  \
+        NSCOMM_LOGERR("point check fail] desc_para=%s", desc); \
+        return NULL; \
+    }
+
+/*if input point is nun, just return err num*/
+#define NSFW_POINT_CHK_RET_ERR(p, desc) \
+    if (NULL == (p))  \
+    {  \
+        NSCOMM_LOGDBG("point check fail] desc_para=%s", desc); \
+        return NSFW_MEM_ERR; \
+    }
+
+/*if input point is nun, goto flag*/
+#define NSFW_POINT_CHK_RET_GOTO(p, gotoflag, desc) \
+    if (NULL == (p))  \
+    {  \
+        NSCOMM_LOGERR("point check fail] desc_para=%s", desc); \
+        goto gotoflag; \
+    }
+
+/*init the msg head*/
+#define NSFW_SHMEM_MSG_HEAD_INIT(pmsg, type, lenth) { \
+        (pmsg)->usmsg_type = (type); \
+        (pmsg)->uslenth = (lenth); \
+    }
+
+/*rsp msg head check, and if err goto*/
+#define NSFW_SHMEM_MSGHEAD_CHK_GOTO(pmsg, type, lenth, gotoflag) { \
+        if (((type) != pmsg->usmsg_type) && ((lenth) != pmsg->uslenth)) \
+        {  \
+            NSCOMM_LOGERR("check fail] msgtype=%d, type_para=%d, len=%d", (pmsg->usmsg_type), (type), (lenth)); \
+            goto gotoflag;  \
+        }  \
+    }
+
+/*rsp check the state*/
+#define NSFW_SHMEM_ACKSTATE_CHK_GOTO(expret, ret, expseg, seg, gotoflag) { \
+        if (((ret) != (expret)) || ((expseg) != (seg))) \
+        {  \
+            NSCOMM_LOGERR("ackstate check fail]msgack exp=%d, real=%d,eseg=%d, rseg=%d", (expret), (ret), (expseg), (seg)); \
+            goto gotoflag; \
+        }   \
+    }
+
+/*mzone msg init*/
+#define NSFW_SHMEM_MZONE_DATA_INIT(pdata, slenth, seg, socketid) { \
+        (pdata)->isocket_id = (socketid); \
+        (pdata)->lenth = (slenth); \
+        (pdata)->usseq = (seg); \
+        (pdata)->ireserv = 0; \
+    }
+
+/*mbuf msg init*/
+#define NSFW_SHMEM_MBUF_DATA_INIT(pdata, seg, num, cashsize, priv_size, data_room, flag, socketid) { \
+        (pdata)->usseq = (seg); \
+        (pdata)->usnum = (num); \
+        (pdata)->uscash_size = (cashsize); \
+        (pdata)->uspriv_size = (priv_size); \
+        (pdata)->usdata_room = (data_room); \
+        (pdata)->enmptype = (flag); \
+        (pdata)->isocket_id = (socketid); \
+        (pdata)->ireserv = 0; \
+    }
+
+/*mpool msg init*/
+#define NSFW_SHMEM_MPOOL_DATA_INIT(pdata, seg, num, eltsize, flag, socketid) { \
+        (pdata)->usseq = (seg); \
+        (pdata)->usnum = (num); \
+        (pdata)->useltsize = (eltsize);  \
+        (pdata)->enmptype = (flag); \
+        (pdata)->isocket_id = (socketid); \
+        (pdata)->ireserv = 0; \
+    }
+
+/*mring msg init*/
+#define NSFW_SHMEM_MRING_DATA_INIT(pdata, seg, num, flag, socketid) { \
+        (pdata)->usseq = (seg);     \
+        (pdata)->usnum = (num);  \
+        (pdata)->enmptype = (flag);  \
+        (pdata)->isocket_id = (socketid);  \
+        (pdata)->ireserv = 0; \
+    }
+
+#define NSFW_SHMEM_MSG_FREE(pmsg, prsp_msg) {\
+    if (pmsg) \
+    { \
+        nsfw_mgr_msg_free(pmsg); \
+    } \
+    if (prsp_msg) \
+    { \
+        nsfw_mgr_msg_free(prsp_msg); \
+    }  \
+}
+
+/*
+ * create a block memory by send a msg
+ *
+ */
+mzone_handle
+nsfw_memzone_remote_reserv (const i8 * name, size_t mlen, i32 socket_id)
+{
+  /*msg point define */
+  nsfw_mgr_msg *pmsg = NULL;
+  nsfw_mgr_msg *prsp_msg = NULL;
+
+  /*msg head point define */
+  nsfw_shmem_msg_head *pdata_head = NULL;
+
+  /*msg data point define */
+  nsfw_shmem_reserv_req *pdata = NULL;
+  nsfw_shmem_msg_head *pack_head = NULL;
+
+  /*ack msg define */
+  nsfw_shmem_ack *pack_data = NULL;
+
+  mzone_handle hhandle = NULL;
+  u8 ucret = TRUE;
+  i32 iretval = NSFW_MEM_OK;
+
+  //pmsg = nsfw_mgr_msg_alloc(MGR_MSG_MEM_ALLOC_REQ, NSFW_PROC_MASTER);
+  pmsg = nsfw_mgr_msg_alloc (MGR_MSG_MEM_ALLOC_REQ, NSFW_PROC_MAIN);
+  NSFW_POINT_CHK_RET_NULL (pmsg, "remote reserv pmsg alloc");
+
+  prsp_msg = nsfw_mgr_null_rspmsg_alloc ();
+  NSFW_POINT_CHK_RET_GOTO (prsp_msg, release, "remote reserv rspmsg alloc");
+
+  /*msg head init */
+  pdata_head = GET_USER_MSG (nsfw_shmem_msg_head, pmsg);
+  NSFW_SHMEM_MSG_HEAD_INIT (pdata_head, NSFW_RESERV_REQ_MSG,
+                            sizeof (nsfw_shmem_reserv_req));
+
+  /*msg data init */
+  pdata = NSFW_SHMEM_GET_DATA (pdata_head, nsfw_shmem_reserv_req);
+  iretval = STRCPY_S (pdata->aname, sizeof (pdata->aname), name);
+  if (EOK != iretval)
+    {
+      NSCOMM_LOGERR ("reserv mem copy name fail] ret=%d", iretval);
+      goto release;
+    }
+
+  /*fill msg data */
+  NSFW_SHMEM_MZONE_DATA_INIT (pdata, mlen, (u16) 0, socket_id);
+
+  ucret = nsfw_mgr_send_req_wait_rsp (pmsg, prsp_msg);
+
+  if (FALSE == ucret)
+    {
+      NSCOMM_LOGERR ("reserv mem req rsp fail] ret=%u", ucret);
+      goto release;
+    }
+
+  /*interrupt msg head */
+  pack_head = GET_USER_MSG (nsfw_shmem_msg_head, prsp_msg);
+  NSFW_SHMEM_MSGHEAD_CHK_GOTO (pack_head, NSFW_RESERV_ACK_MSG,
+                               sizeof (nsfw_shmem_ack), release);
+
+  pack_data = NSFW_SHMEM_GET_DATA (pack_head, nsfw_shmem_ack);
+  NSFW_SHMEM_ACKSTATE_CHK_GOTO (NSFW_MEM_ALLOC_SUCC, pack_data->cstate, 0,
+                                pack_data->usseq, release);
+
+  hhandle = (mzone_handle) ADDR_SHTOL (pack_data->pbase_addr);
+  NSCOMM_LOGDBG ("mem reserve] name=%s, handle=%p, seg=%u", name, hhandle,
+                 pack_data->usseq);
+release:
+  NSFW_SHMEM_MSG_FREE (pmsg, prsp_msg);
+  return hhandle;
+}
+
+/*
+ *create some memorys by send a msg
+ */
+i32
+nsfw_memzone_remote_reserv_v (nsfw_mem_zone * pmeminfo,
+                              mzone_handle * paddr_array, i32 inum, pid_t pid)
+{
+  /*msg point define */
+  nsfw_mgr_msg *pmsg = NULL;
+  nsfw_mgr_msg *prsp_msg = NULL;
+  nsfw_shmem_msg_head *pdata_head = NULL;
+  nsfw_shmem_reserv_req *pdata = NULL;
+  nsfw_shmem_reserv_req *ptempdata = NULL;
+  nsfw_shmem_msg_head *pack_head = NULL;
+
+  nsfw_shmem_ack *pack_data = NULL;
+  u8 ucret = TRUE;
+  i32 iretval = NSFW_MEM_OK;
+  i32 icount = 0;
+  i32 itindex = 0;
+  i32 iindex = 0;
+  u16 ussegbase = 0;
+  u16 ustempv = 0;
+  i32 ieltnum = 0;
+  i32 ieltnum_max =
+    (NSFW_MGR_MSG_BODY_LEN -
+     sizeof (nsfw_shmem_msg_head)) / sizeof (nsfw_shmem_reserv_req);
+
+  //pmsg = nsfw_mgr_msg_alloc(MGR_MSG_MEM_ALLOC_REQ, NSFW_PROC_MASTER);
+  pmsg = nsfw_mgr_msg_alloc (MGR_MSG_MEM_ALLOC_REQ, NSFW_PROC_MAIN);
+  NSFW_POINT_CHK_RET_GOTO (pmsg, err, "remote reserv_v msg alloc");
+
+  prsp_msg = nsfw_mgr_null_rspmsg_alloc ();
+  NSFW_POINT_CHK_RET_GOTO (prsp_msg, err, "remote reserv_v rspmsg alloc");
+
+  pdata_head = GET_USER_MSG (nsfw_shmem_msg_head, pmsg);
+
+  ptempdata = pdata = NSFW_SHMEM_GET_DATA (pdata_head, nsfw_shmem_reserv_req);
+
+  do
+    {
+      icount++;
+      ieltnum++;
+
+      if (((icount % ieltnum_max) == 0) || (icount >= inum))
+        {
+          NSFW_SHMEM_MSG_HEAD_INIT (pdata_head, NSFW_RESERV_REQ_MSG,
+                                    ieltnum * sizeof (nsfw_shmem_reserv_req));
+
+          itindex = icount - 1;
+          int retVal =
+            SPRINTF_S (ptempdata->aname, sizeof (ptempdata->aname), "%s_%x",
+                       pmeminfo[itindex].stname.aname, pid);
+          if (-1 == retVal)
+            {
+              NSCOMM_LOGERR ("SPRINTF_S faild]ret=%d", retVal);
+            }
+          NSFW_SHMEM_MZONE_DATA_INIT (ptempdata, pmeminfo[itindex].lenth,
+                                      (u16) itindex,
+                                      pmeminfo[itindex].isocket_id);
+
+          ucret = nsfw_mgr_send_req_wait_rsp (pmsg, prsp_msg);
+
+          if (FALSE == ucret)
+            {
+              NSCOMM_LOGERR ("reserv v mem req rsp fail] ret=%u", ucret);
+              goto err;
+            }
+
+          pack_head = GET_USER_MSG (nsfw_shmem_msg_head, prsp_msg);
+          NSFW_SHMEM_MSGHEAD_CHK_GOTO (pack_head, NSFW_RESERV_ACK_MSG,
+                                       ieltnum * sizeof (nsfw_shmem_ack),
+                                       err);
+
+          pack_data = NSFW_SHMEM_GET_DATA (pack_head, nsfw_shmem_ack);
+
+          for (iindex = 0; iindex < ieltnum; iindex++)
+            {
+              ustempv = ussegbase + iindex;
+
+              NSFW_SHMEM_ACKSTATE_CHK_GOTO (NSFW_MEM_ALLOC_SUCC,
+                                            pack_data->cstate, ustempv,
+                                            (u16) pack_data->usseq, err);
+
+              paddr_array[ustempv] = ADDR_SHTOL (pack_data->pbase_addr);
+              NSCOMM_LOGDBG ("remote reserve]index=%u, seg=%u, handle=%p",
+                             ustempv, pack_data->usseq, paddr_array[ustempv]);
+              pack_data++;
+            }
+
+          ussegbase = icount;
+          ieltnum = 0;
+          ptempdata = pdata;
+        }
+      else
+        {
+          itindex = icount - 1;
+          int retVal =
+            SPRINTF_S (ptempdata->aname, sizeof (ptempdata->aname), "%s_%x",
+                       pmeminfo[itindex].stname.aname, pid);
+          if (-1 == retVal)
+            {
+              NSCOMM_LOGERR ("SPRINTF_S faild]ret=%d", retVal);
+            }
+          NSFW_SHMEM_MZONE_DATA_INIT (ptempdata, pmeminfo[itindex].lenth,
+                                      (u16) itindex,
+                                      pmeminfo[itindex].isocket_id);
+          ptempdata++;
+        }
+    }
+  while (icount < inum);
+
+  iretval = NSFW_MEM_OK;
+  goto free;
+
+err:
+  iretval = NSFW_MEM_ERR;
+free:
+  NSFW_SHMEM_MSG_FREE (pmsg, prsp_msg);
+  return iretval;
+}
+
+/*
+ *release a block memory with name by send msg
+ */
+i32
+nsfw_remote_free (const i8 * name, nsfw_mem_struct_type entype)
+{
+  /*msg point define */
+  nsfw_mgr_msg *pmsg = NULL;
+  nsfw_mgr_msg *prsp_msg = NULL;
+
+  nsfw_shmem_msg_head *pdata_head = NULL;
+
+  nsfw_shmem_free_req *pdata = NULL;
+
+  nsfw_shmem_msg_head *pack_head = NULL;
+  nsfw_shmem_ack *pack_data = NULL;
+  u8 ucret = TRUE;
+  i32 iretval = NSFW_MEM_OK;
+
+  pmsg = nsfw_mgr_msg_alloc (MGR_MSG_MEM_ALLOC_REQ, NSFW_PROC_MAIN);
+  NSFW_POINT_CHK_RET_ERR (pmsg, "remote free msg alloc");
+
+  prsp_msg = nsfw_mgr_null_rspmsg_alloc ();
+  NSFW_POINT_CHK_RET_GOTO (prsp_msg, terr, "remote free rspmsg alloc");
+
+  pdata_head = GET_USER_MSG (nsfw_shmem_msg_head, pmsg);
+  NSFW_SHMEM_MSG_HEAD_INIT (pdata_head, NSFW_RELEASE_REQ_MSG,
+                            sizeof (nsfw_shmem_free_req));
+
+  pdata = NSFW_SHMEM_GET_DATA (pdata_head, nsfw_shmem_free_req);
+  if (EOK != STRCPY_S (pdata->aname, sizeof (pdata->aname), name))
+    {
+      NSCOMM_LOGERR ("STRCPY_S failed]name=%s", name);
+    }
+  pdata->usseq = 0;
+  pdata->ustype = entype;
+  pdata->ireserv = 0;
+
+  ucret = nsfw_mgr_send_req_wait_rsp (pmsg, prsp_msg);
+
+  if (FALSE == ucret)
+    {
+      NSCOMM_LOGERR ("free mem req rsp fail] ret=%u", ucret);
+      goto release;
+    }
+
+  pack_head = GET_USER_MSG (nsfw_shmem_msg_head, prsp_msg);
+  NSFW_SHMEM_MSGHEAD_CHK_GOTO (pack_head, NSFW_RELEASE_ACK_MSG,
+                               sizeof (nsfw_shmem_ack), terr);
+
+  pack_data = NSFW_SHMEM_GET_DATA (pack_head, nsfw_shmem_ack);
+  NSFW_SHMEM_ACKSTATE_CHK_GOTO (NSFW_MEM_ALLOC_SUCC, pack_data->cstate, 0,
+                                pack_data->usseq, terr);
+
+  iretval = NSFW_MEM_OK;
+  goto release;
+terr:
+  iretval = NSFW_MEM_ERR;
+release:
+  NSFW_SHMEM_MSG_FREE (pmsg, prsp_msg);
+  return iretval;
+}
+
+/*
+ *create a mbuf pool by send a msg
+ */
+mpool_handle
+nsfw_remote_shmem_mbf_create (const i8 * name, unsigned n,
+                              unsigned cache_size, unsigned priv_size,
+                              unsigned data_room_size, i32 socket_id,
+                              nsfw_mpool_type entype)
+{
+  /*msg point define */
+  nsfw_mgr_msg *pmsg = NULL;
+  nsfw_mgr_msg *prsp_msg = NULL;
+  nsfw_shmem_msg_head *pdata_head = NULL;
+  nsfw_shmem_mbuf_req *pdata = NULL;
+  nsfw_shmem_msg_head *tpack_head = NULL;
+  nsfw_shmem_ack *tpack_data = NULL;
+  mpool_handle hhandle = NULL;
+  u8 ucret = TRUE;
+  i32 iretval = NSFW_MEM_OK;
+
+  pmsg = nsfw_mgr_msg_alloc (MGR_MSG_MEM_ALLOC_REQ, NSFW_PROC_MAIN);
+  NSFW_POINT_CHK_RET_NULL (pmsg, "remote mbf create pmsg alloc");
+
+  prsp_msg = nsfw_mgr_null_rspmsg_alloc ();
+  NSFW_POINT_CHK_RET_GOTO (prsp_msg, release, "remote mbf create msg alloc");
+
+  pdata_head = GET_USER_MSG (nsfw_shmem_msg_head, pmsg);
+  NSFW_SHMEM_MSG_HEAD_INIT (pdata_head, NSFW_MBUF_REQ_MSG,
+                            sizeof (nsfw_shmem_mbuf_req));
+
+  pdata = NSFW_SHMEM_GET_DATA (pdata_head, nsfw_shmem_mbuf_req);
+  iretval = STRCPY_S (pdata->aname, sizeof (pdata->aname), name);
+  if (EOK != iretval)
+    {
+      NSCOMM_LOGERR ("mbf create name cpy fail] ret=%d", iretval);
+      goto release;
+    }
+
+  NSFW_SHMEM_MBUF_DATA_INIT (pdata, 0, n, cache_size, priv_size,
+                             data_room_size, (u16) entype, socket_id);
+
+  ucret = nsfw_mgr_send_req_wait_rsp (pmsg, prsp_msg);
+
+  if (FALSE == ucret)
+    {
+      NSCOMM_LOGERR ("mbf create mem req rsp fail] ret=%u", ucret);
+      goto release;
+    }
+
+  tpack_head = GET_USER_MSG (nsfw_shmem_msg_head, prsp_msg);
+  NSFW_SHMEM_MSGHEAD_CHK_GOTO (tpack_head, NSFW_MBUF_ACK_MSG,
+                               sizeof (nsfw_shmem_ack), release);
+
+  tpack_data = NSFW_SHMEM_GET_DATA (tpack_head, nsfw_shmem_ack);
+  NSFW_SHMEM_ACKSTATE_CHK_GOTO (NSFW_MEM_ALLOC_SUCC, tpack_data->cstate, 0,
+                                tpack_data->usseq, release);
+
+  hhandle = ADDR_SHTOL (tpack_data->pbase_addr);
+  NSCOMM_LOGDBG ("mbf create] name=%s, handle=%p, seg=%u", name, hhandle,
+                 tpack_data->usseq);
+release:
+  NSFW_SHMEM_MSG_FREE (pmsg, prsp_msg);
+  return hhandle;
+}
+
+/*
+ *create some mbuf pools
+ */
+i32
+nsfw_remote_shmem_mbf_createv (nsfw_mem_mbfpool * pmbfname,
+                               mpool_handle * phandle_array, i32 inum,
+                               pid_t pid)
+{
+  /*msg point define */
+  nsfw_mgr_msg *mbpmsg = NULL;
+  nsfw_mgr_msg *prsp_msg = NULL;
+  nsfw_shmem_msg_head *pdata_head = NULL;
+
+  nsfw_shmem_mbuf_req *pdata = NULL;
+  nsfw_shmem_mbuf_req *ptempdata = NULL;
+
+  nsfw_shmem_msg_head *pack_head = NULL;
+
+  nsfw_shmem_ack *pack_data = NULL;
+  mpool_handle hhandle = NULL;
+  u8 ucret = TRUE;
+  i32 iretval = NSFW_MEM_OK;
+  i32 icount = 0;
+  i32 itindex = 0;
+  i32 iindex = 0;
+  i32 isegbase = 0;
+  i32 ieltnum = 0;
+  i32 ieltnum_max =
+    (NSFW_MGR_MSG_BODY_LEN -
+     sizeof (nsfw_shmem_msg_head)) / sizeof (nsfw_shmem_mbuf_req);
+
+  mbpmsg = nsfw_mgr_msg_alloc (MGR_MSG_MEM_ALLOC_REQ, NSFW_PROC_MAIN);
+  NSFW_POINT_CHK_RET_GOTO (mbpmsg, lerr, "remote mbf createv msg alloc");
+
+  prsp_msg = nsfw_mgr_null_rspmsg_alloc ();
+  NSFW_POINT_CHK_RET_GOTO (prsp_msg, lerr, "remote mbf createv rspmsg alloc");
+
+  pdata_head = GET_USER_MSG (nsfw_shmem_msg_head, mbpmsg);
+
+  ptempdata = pdata = NSFW_SHMEM_GET_DATA (pdata_head, nsfw_shmem_mbuf_req);
+
+  do
+    {
+      icount++;
+      ieltnum++;
+
+      if (((icount % ieltnum_max) == 0) || (icount >= inum))
+        {
+          NSFW_SHMEM_MSG_HEAD_INIT (pdata_head, NSFW_MBUF_REQ_MSG,
+                                    ieltnum * sizeof (nsfw_shmem_mbuf_req));
+
+          /*fill msg data */
+          itindex = icount - 1;
+          if (-1 ==
+              SPRINTF_S (ptempdata->aname, sizeof (ptempdata->aname), "%s_%x",
+                         pmbfname[itindex].stname.aname, pid))
+            {
+              NSCOMM_LOGERR ("SPRINTF_S failed]");
+              goto lerr;
+            }
+          NSFW_SHMEM_MBUF_DATA_INIT (ptempdata, (u16) itindex,
+                                     pmbfname[itindex].usnum,
+                                     pmbfname[itindex].uscash_size,
+                                     pmbfname[itindex].uspriv_size,
+                                     pmbfname[itindex].usdata_room,
+                                     pmbfname[itindex].enmptype,
+                                     pmbfname[itindex].isocket_id);
+
+          ucret = nsfw_mgr_send_req_wait_rsp (mbpmsg, prsp_msg);
+
+          if (FALSE == ucret)
+            {
+              NSCOMM_LOGERR ("mbf createv mem req rsp fail] ret=%d", ucret);
+              goto lerr;
+            }
+
+          /*interrup msg head */
+          pack_head = GET_USER_MSG (nsfw_shmem_msg_head, prsp_msg);
+          NSFW_SHMEM_MSGHEAD_CHK_GOTO (pack_head, NSFW_MBUF_ACK_MSG,
+                                       ieltnum * sizeof (nsfw_shmem_ack),
+                                       lerr);
+
+          pack_data = NSFW_SHMEM_GET_DATA (pack_head, nsfw_shmem_ack);
+
+          for (iindex = 0; iindex < ieltnum; iindex++)
+            {
+              NSFW_SHMEM_ACKSTATE_CHK_GOTO (NSFW_MEM_ALLOC_SUCC,
+                                            pack_data->cstate,
+                                            (isegbase + iindex),
+                                            (u16) pack_data->usseq, lerr);
+              phandle_array[isegbase + iindex] =
+                ADDR_SHTOL (pack_data->pbase_addr);
+              NSCOMM_LOGDBG ("mbf createv] seg=%d, handle=%p",
+                             pack_data->usseq, hhandle);
+              pack_data++;
+            }
+
+          isegbase = icount;
+          ieltnum = 0;
+          ptempdata = pdata;
+        }
+      else
+        {
+          itindex = icount - 1;
+          if (-1 ==
+              SPRINTF_S (ptempdata->aname, sizeof (ptempdata->aname), "%s_%x",
+                         pmbfname[itindex].stname.aname, pid))
+            {
+              NSCOMM_LOGERR ("SPRINTF_S failed]");
+              goto lerr;
+            }
+          NSFW_SHMEM_MBUF_DATA_INIT (ptempdata, (u16) itindex,
+                                     pmbfname[itindex].usnum,
+                                     pmbfname[itindex].uscash_size,
+                                     pmbfname[itindex].uspriv_size,
+                                     pmbfname[itindex].usdata_room,
+                                     pmbfname[itindex].enmptype,
+                                     pmbfname[itindex].isocket_id);
+          ptempdata++;
+        }
+    }
+  while (icount < inum);
+
+  /*release memory */
+  iretval = NSFW_MEM_OK;
+  goto release;
+
+lerr:
+  iretval = NSFW_MEM_ERR;
+release:
+  NSFW_SHMEM_MSG_FREE (mbpmsg, prsp_msg);
+  return iretval;
+}
+
+/*
+ *create a simpile pool
+ */
+mring_handle
+nsfw_remote_shmem_mpcreate (const char *name, unsigned int n,
+                            unsigned int elt_size, i32 socket_id,
+                            nsfw_mpool_type entype)
+{
+  /*msg point define */
+  nsfw_mgr_msg *pmsg = NULL;
+  nsfw_mgr_msg *prsp_msg = NULL;
+  nsfw_shmem_msg_head *pdata_head = NULL;
+  nsfw_shmem_sppool_req *pdata = NULL;
+  nsfw_shmem_msg_head *mppack_head = NULL;
+  nsfw_shmem_ack *mppack_data = NULL;
+  mring_handle hhandle = NULL;
+  u8 ucret = TRUE;
+  i32 iretval = NSFW_MEM_OK;
+
+  pmsg = nsfw_mgr_msg_alloc (MGR_MSG_MEM_ALLOC_REQ, NSFW_PROC_MAIN);
+  NSFW_POINT_CHK_RET_NULL (pmsg, "remote mbf mpcreate pmsg alloc");
+
+  prsp_msg = nsfw_mgr_null_rspmsg_alloc ();
+  NSFW_POINT_CHK_RET_GOTO (prsp_msg, release, "remote mpcreate rspmsg alloc");
+
+  /*init msg head */
+  pdata_head = GET_USER_MSG (nsfw_shmem_msg_head, pmsg);
+  NSFW_SHMEM_MSG_HEAD_INIT (pdata_head, NSFW_SPPOOL_REQ_MSG,
+                            sizeof (nsfw_shmem_sppool_req));
+
+  /*fill msg data */
+  pdata = NSFW_SHMEM_GET_DATA (pdata_head, nsfw_shmem_sppool_req);
+  iretval = STRCPY_S (pdata->aname, sizeof (pdata->aname), name);
+  if (EOK != iretval)
+    {
+      NSCOMM_LOGERR ("mp create copy name fail] ret=%d", iretval);
+      goto release;
+    }
+
+  /*fill msg data */
+  NSFW_SHMEM_MPOOL_DATA_INIT (pdata, 0, n, elt_size, entype, socket_id);
+
+  ucret = nsfw_mgr_send_req_wait_rsp (pmsg, prsp_msg);
+
+  if (FALSE == ucret)
+    {
+      NSCOMM_LOGERR ("mp create rsp fail] ret=%d", ucret);
+      goto release;
+    }
+
+  /*get msg head */
+  mppack_head = GET_USER_MSG (nsfw_shmem_msg_head, prsp_msg);
+  NSFW_SHMEM_MSGHEAD_CHK_GOTO (mppack_head, NSFW_SPPOOL_ACK_MSG,
+                               sizeof (nsfw_shmem_ack), release);
+
+  mppack_data = NSFW_SHMEM_GET_DATA (mppack_head, nsfw_shmem_ack);
+  NSFW_SHMEM_ACKSTATE_CHK_GOTO (NSFW_MEM_ALLOC_SUCC, mppack_data->cstate, 0,
+                                mppack_data->usseq, release);
+
+  hhandle = ADDR_SHTOL (mppack_data->pbase_addr);
+  NSCOMM_LOGDBG ("mpcreate] name=%s, handle=%p, seg=%d", name, hhandle,
+                 mppack_data->usseq);
+release:
+  NSFW_SHMEM_MSG_FREE (pmsg, prsp_msg);
+  return hhandle;
+}
+
+/*
+ *create some simpile pools by send a msg
+ */
+i32
+nsfw_remote_shmem_mpcreatev (nsfw_mem_sppool * pmpinfo,
+                             mring_handle * pringhandle_array, i32 inum,
+                             pid_t pid)
+{
+  /*msg point define */
+  nsfw_mgr_msg *pmsg = NULL;
+  nsfw_mgr_msg *prsp_msg = NULL;
+
+  /*msg head define */
+  nsfw_shmem_msg_head *pdata_head = NULL;
+
+  /*msg data define */
+  nsfw_shmem_sppool_req *pdata = NULL;
+  nsfw_shmem_sppool_req *ptempdata = NULL;
+
+  /*ack msg define */
+  nsfw_shmem_msg_head *pack_head = NULL;
+
+  nsfw_shmem_ack *pack_data = NULL;
+  mring_handle hhandle = NULL;
+  u8 ucret = TRUE;
+  i32 iretval = NSFW_MEM_OK;
+  i32 icount = 0;
+  i32 itindex = 0;
+  i32 iindex = 0;
+  i32 isegbase = 0;
+  i32 ieltnum = 0;
+  /*the max members that a msg can take */
+  i32 ieltnum_max =
+    (NSFW_MGR_MSG_BODY_LEN -
+     sizeof (nsfw_shmem_msg_head)) / sizeof (nsfw_shmem_sppool_req);
+
+  /*alloc a msg */
+  //pmsg = nsfw_mgr_msg_alloc(MGR_MSG_MEM_ALLOC_REQ, NSFW_PROC_MASTER);
+  pmsg = nsfw_mgr_msg_alloc (MGR_MSG_MEM_ALLOC_REQ, NSFW_PROC_MAIN);
+  NSFW_POINT_CHK_RET_GOTO (pmsg, mperr, "remote mpcreatev pmsg alloc");
+
+  /*alloc rsp msg */
+  prsp_msg = nsfw_mgr_null_rspmsg_alloc ();
+  NSFW_POINT_CHK_RET_GOTO (prsp_msg, mperr, "remote mpcreatev rspmsg alloc");
+
+  pdata_head = GET_USER_MSG (nsfw_shmem_msg_head, pmsg);
+
+  ptempdata = pdata = NSFW_SHMEM_GET_DATA (pdata_head, nsfw_shmem_sppool_req);
+
+  do
+    {
+      icount++;
+      ieltnum++;
+
+      /*if the element num reach the bigest, or already send all, just deal */
+      if (((icount % ieltnum_max) == 0) || (icount >= inum))
+        {
+          /*init msg header */
+          NSFW_SHMEM_MSG_HEAD_INIT (pdata_head, NSFW_SPPOOL_REQ_MSG,
+                                    ieltnum * sizeof (nsfw_shmem_sppool_req));
+
+          /*fill the msg data */
+          itindex = icount - 1;
+
+          int retVal =
+            SPRINTF_S (ptempdata->aname, sizeof (ptempdata->aname), "%s_%x",
+                       pmpinfo[itindex].stname.aname, pid);
+          if (-1 == retVal)
+            {
+              NSCOMM_LOGERR ("SPRINTF_S fail]ret=%d", retVal);
+              goto mperr;
+            }
+          NSFW_SHMEM_MPOOL_DATA_INIT (ptempdata, itindex,
+                                      pmpinfo[itindex].usnum,
+                                      pmpinfo[itindex].useltsize,
+                                      pmpinfo[itindex].enmptype,
+                                      pmpinfo[itindex].isocket_id);
+
+          ucret = nsfw_mgr_send_req_wait_rsp (pmsg, prsp_msg);
+
+          if (FALSE == ucret)
+            {
+              NSCOMM_LOGERR ("mpcreatev create fail] ret=%u", ucret);
+              goto mperr;
+            }
+
+          /*interrup mgs head */
+          pack_head = GET_USER_MSG (nsfw_shmem_msg_head, prsp_msg);
+          NSFW_SHMEM_MSGHEAD_CHK_GOTO (pack_head, NSFW_SPPOOL_ACK_MSG,
+                                       ieltnum * sizeof (nsfw_shmem_ack),
+                                       mperr);
+
+          pack_data = NSFW_SHMEM_GET_DATA (pack_head, nsfw_shmem_ack);
+
+          for (iindex = 0; iindex < ieltnum; iindex++)
+            {
+              NSFW_SHMEM_ACKSTATE_CHK_GOTO (NSFW_MEM_ALLOC_SUCC,
+                                            pack_data->cstate,
+                                            (isegbase + iindex),
+                                            (u16) pack_data->usseq, mperr);
+              pringhandle_array[isegbase + iindex] =
+                ADDR_SHTOL (pack_data->pbase_addr);
+              NSCOMM_LOGDBG ("mpcreatev] seg=%u, handle=%p", pack_data->usseq,
+                             hhandle);
+              pack_data++;
+            }
+
+          isegbase = icount;
+          ieltnum = 0;
+          ptempdata = pdata;
+        }
+      else
+        {
+          itindex = icount - 1;
+          int retVal =
+            SPRINTF_S (ptempdata->aname, sizeof (ptempdata->aname), "%s_%x",
+                       pmpinfo[itindex].stname.aname, pid);
+          if (-1 == retVal)
+            {
+              NSCOMM_LOGERR ("SPRINTF_S fail]ret=%d", retVal);
+              goto mperr;
+            }
+          NSFW_SHMEM_MPOOL_DATA_INIT (ptempdata, itindex,
+                                      pmpinfo[itindex].usnum,
+                                      pmpinfo[itindex].useltsize,
+                                      pmpinfo[itindex].enmptype,
+                                      pmpinfo[itindex].isocket_id);
+
+          ptempdata++;
+        }
+    }
+  while (icount < inum);
+
+  /*release the memory */
+  iretval = NSFW_MEM_OK;
+  goto release;
+
+mperr:
+  iretval = NSFW_MEM_ERR;
+release:
+  NSFW_SHMEM_MSG_FREE (pmsg, prsp_msg);
+  return iretval;
+}
+
+/*
+ *create a ring
+ */
+mring_handle
+nsfw_remote_shmem_ringcreate (const char *name, unsigned int n, i32 socket_id,
+                              nsfw_mpool_type entype)
+{
+  /*msg point define */
+  nsfw_mgr_msg *pmsg = NULL;
+  nsfw_mgr_msg *prsp_msg = NULL;
+
+  /*msg head define */
+  nsfw_shmem_msg_head *pdata_head = NULL;
+
+  /*msg data define */
+  nsfw_shmem_ring_req *pdata = NULL;
+  /*ack msg define */
+  nsfw_shmem_msg_head *pack_head = NULL;
+  nsfw_shmem_ack *ppack_data = NULL;
+  mring_handle hhandle = NULL;
+  u8 ucret = TRUE;
+  i32 iretval = NSFW_MEM_OK;
+
+  //pmsg = nsfw_mgr_msg_alloc(MGR_MSG_MEM_ALLOC_REQ, NSFW_PROC_MASTER);
+  pmsg = nsfw_mgr_msg_alloc (MGR_MSG_MEM_ALLOC_REQ, NSFW_PROC_MAIN);
+  NSFW_POINT_CHK_RET_NULL (pmsg, "remote ringcreate pmsg alloc");
+
+  prsp_msg = nsfw_mgr_null_rspmsg_alloc ();
+  NSFW_POINT_CHK_RET_GOTO (prsp_msg, release,
+                           "remote ringcreate rspmsg alloc");
+
+  /*fill msg head */
+  pdata_head = GET_USER_MSG (nsfw_shmem_msg_head, pmsg);
+  NSFW_SHMEM_MSG_HEAD_INIT (pdata_head, NSFW_RING_REQ_MSG,
+                            sizeof (nsfw_shmem_ring_req));
+
+  /*fill msg data */
+  pdata = NSFW_SHMEM_GET_DATA (pdata_head, nsfw_shmem_ring_req);
+  iretval = STRCPY_S (pdata->aname, sizeof (pdata->aname), name);
+  if (EOK != iretval)
+    {
+      NSCOMM_LOGERR ("ring create cpy name fail] ret=%d", iretval);
+      goto release;
+    }
+
+  /*fill msg data */
+  NSFW_SHMEM_MRING_DATA_INIT (pdata, 0, n, entype, socket_id);
+
+  ucret = nsfw_mgr_send_req_wait_rsp (pmsg, prsp_msg);
+
+  if (FALSE == ucret)
+    {
+      NSCOMM_LOGERR ("ring create rsp fail] ret=%d", ucret);
+      goto release;
+    }
+
+  /*interrup mgs head */
+  pack_head = GET_USER_MSG (nsfw_shmem_msg_head, prsp_msg);
+  NSFW_SHMEM_MSGHEAD_CHK_GOTO (pack_head, NSFW_RING_ACK_MSG,
+                               sizeof (nsfw_shmem_ack), release);
+
+  ppack_data = NSFW_SHMEM_GET_DATA (pack_head, nsfw_shmem_ack);
+  NSFW_SHMEM_ACKSTATE_CHK_GOTO (NSFW_MEM_ALLOC_SUCC, ppack_data->cstate, 0,
+                                ppack_data->usseq, release);
+
+  hhandle = ADDR_SHTOL (ppack_data->pbase_addr);
+  NSCOMM_LOGDBG ("ring create] name=%s, handle=%p, seg=%u", name, hhandle,
+                 ppack_data->usseq);
+release:
+  NSFW_SHMEM_MSG_FREE (pmsg, prsp_msg);
+  return hhandle;
+}
+
+/*
+ *create a mem pool that the members are rings by send a msg
+ *ieltnum:the num of ring member
+ *iringnum:the num of ring in simple mem pook
+ *entype:the defualt the of ring
+ */
+i32
+nsfw_remote_shmem_ringcreatev (const char *name, i32 ieltnum,
+                               mring_handle * pringhandle_array, i32 iringnum,
+                               i32 socket_id, nsfw_mpool_type entype)
+{
+  unsigned int useltsize = 0;
+  mring_handle nhandle = NULL;
+  i32 icount = 0;
+  i32 n = 0;
+  uint64_t baseaddr = 0;
+  uint64_t endaddr = 0;
+  /*the num of ring member must be power of 2 */
+  unsigned int usnum = common_mem_align32pow2 (ieltnum + 1);
+
+  useltsize =
+    sizeof (struct nsfw_mem_ring) + usnum * sizeof (union RingData_U);
+  nhandle =
+    nsfw_remote_shmem_mpcreate (name, iringnum, useltsize, socket_id,
+                                NSFW_MRING_SPSC);
+  NSFW_POINT_CHK_RET_ERR (nhandle, "remote ringcreatev msg alloc");
+
+  n =
+    nsfw_shmem_ring_sc_dequeuev (nhandle, (void **) pringhandle_array,
+                                 iringnum);
+
+  if (n != iringnum)
+    {
+      NSCOMM_LOGERR ("ring dequeue fail] ringnum=%d, retnum=%d", iringnum, n);
+      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;
+}
+
+/*
+ *look up a msg by send a msg
+ */
+void *
+nsfw_remote_shmem_lookup (const i8 * name, nsfw_mem_struct_type entype)
+{
+  /*msg point define */
+  nsfw_mgr_msg *pmsg = NULL;
+  nsfw_mgr_msg *prsp_msg = NULL;
+  void *addr = NULL;
+  /*msg head data define */
+  nsfw_shmem_msg_head *pdata_head = NULL;
+
+  /*msg data define */
+  nsfw_shmem_lookup_req *pdata = NULL;
+
+  /*ack msg define */
+  nsfw_shmem_msg_head *pack_head = NULL;
+  nsfw_shmem_ack *lpack_data = NULL;
+  u8 ucret = TRUE;
+
+  pmsg = nsfw_mgr_msg_alloc (MGR_MSG_MEM_ALLOC_REQ, NSFW_PROC_MAIN);
+  NSFW_POINT_CHK_RET_NULL (pmsg, "remote lookup pmsg alloc");
+
+  prsp_msg = nsfw_mgr_null_rspmsg_alloc ();
+  NSFW_POINT_CHK_RET_GOTO (prsp_msg, perr, "remote lookup rspmsg alloc");
+
+  /*msg head init */
+  pdata_head = GET_USER_MSG (nsfw_shmem_msg_head, pmsg);
+  NSFW_SHMEM_MSG_HEAD_INIT (pdata_head, NSFW_MEM_LOOKUP_REQ_MSG,
+                            sizeof (nsfw_shmem_lookup_req));
+
+  pdata = NSFW_SHMEM_GET_DATA (pdata_head, nsfw_shmem_lookup_req);
+  if (EOK != STRCPY_S (pdata->aname, sizeof (pdata->aname), name))
+    {
+      NSCOMM_LOGERR ("STRCPY_S faild]name=%s", name);
+    }
+  pdata->usseq = 0;
+  pdata->ustype = entype;
+  pdata->ireserv = 0;
+
+  ucret = nsfw_mgr_send_req_wait_rsp (pmsg, prsp_msg);
+
+  if (FALSE == ucret)
+    {
+      NSCOMM_LOGERR ("mem lookup fail] ret=%u", ucret);
+      goto release;
+    }
+
+  /*interrup mgs head */
+  pack_head = GET_USER_MSG (nsfw_shmem_msg_head, prsp_msg);
+  NSFW_SHMEM_MSGHEAD_CHK_GOTO (pack_head, NSFW_MEM_LOOKUP_ACK_MSG,
+                               sizeof (nsfw_shmem_ack), perr);
+
+  lpack_data = NSFW_SHMEM_GET_DATA (pack_head, nsfw_shmem_ack);
+  NSFW_SHMEM_ACKSTATE_CHK_GOTO (NSFW_MEM_ALLOC_SUCC, lpack_data->cstate, 0,
+                                lpack_data->usseq, perr);
+
+  addr = ADDR_SHTOL (lpack_data->pbase_addr);
+  NSCOMM_LOGDBG ("shmem lookup] name=%s, handle=%p, seg=%u", name, addr,
+                 lpack_data->usseq);
+  goto release;
+perr:
+  addr = NULL;
+
+release:
+  NSFW_SHMEM_MSG_FREE (pmsg, prsp_msg);
+  return addr;
+}
diff --git a/src/framework/common/mem_mgr/nsfw_shmem/nsfw_rshmem_mng.h b/src/framework/common/mem_mgr/nsfw_shmem/nsfw_rshmem_mng.h
new file mode 100644
index 0000000..60c4115
--- /dev/null
+++ b/src/framework/common/mem_mgr/nsfw_shmem/nsfw_rshmem_mng.h
@@ -0,0 +1,51 @@
+/*
+*
+* 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.
+*/
+
+#ifndef _NSFW_RSHMEM_MNG_H
+#define _NSFW_RSHMEM_MNG_H
+
+mzone_handle nsfw_memzone_remote_reserv (const i8 * name, size_t mlen,
+                                         i32 socket_id);
+i32 nsfw_memzone_remote_reserv_v (nsfw_mem_zone * pmeminfo,
+                                  mzone_handle * paddr_array, i32 inum,
+                                  pid_t pid);
+i32 nsfw_remote_free (const i8 * name, nsfw_mem_struct_type entype);
+mpool_handle nsfw_remote_shmem_mbf_create (const i8 * name, unsigned int n,
+                                           unsigned cache_size,
+                                           unsigned priv_size,
+                                           unsigned data_room_size,
+                                           i32 socket_id,
+                                           nsfw_mpool_type entype);
+i32 nsfw_remote_shmem_mbf_createv (nsfw_mem_mbfpool * pmbfname,
+                                   mpool_handle * phandle_array, i32 inum,
+                                   pid_t pid);
+mring_handle nsfw_remote_shmem_mpcreate (const char *name, unsigned int n,
+                                         unsigned int elt_size, i32 socket_id,
+                                         nsfw_mpool_type entype);
+i32 nsfw_remote_shmem_mpcreatev (nsfw_mem_sppool * pmpinfo,
+                                 mring_handle * pringhandle_array, i32 inum,
+                                 pid_t pid);
+mring_handle nsfw_remote_shmem_ringcreate (const char *name, unsigned int n,
+                                           i32 socket_id,
+                                           nsfw_mpool_type entype);
+i32 nsfw_remote_shmem_ringcreatev (const char *name, i32 ieltnum,
+                                   mring_handle * pringhandle_array,
+                                   i32 iringnum, i32 socket_id,
+                                   nsfw_mpool_type entype);
+
+void *nsfw_remote_shmem_lookup (const i8 * name, nsfw_mem_struct_type entype);
+
+#endif
diff --git a/src/framework/common/mem_mgr/nsfw_shmem/nsfw_shmem_mdesc.c b/src/framework/common/mem_mgr/nsfw_shmem/nsfw_shmem_mdesc.c
new file mode 100644
index 0000000..e7a11ad
--- /dev/null
+++ b/src/framework/common/mem_mgr/nsfw_shmem/nsfw_shmem_mdesc.c
@@ -0,0 +1,47 @@
+/*
+*
+* 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 "nsfw_mem_desc.h"
+#include "nsfw_shmem_mng.h"
+#include "nsfw_shmem_mdesc.h"
+
+/*the inferaces accessing memory*/
+nsfw_mem_ops g_shmem_ops = {
+  nsfw_shmem_init,
+  nsfw_shmem_destroy,
+  nsfw_shmem_create,
+  nsfw_shmem_createv,
+  nsfw_shmem_lookup,
+  nsfw_shmem_release,
+  nsfw_shmem_mbfmpcreate,
+  nsfw_shmem_mbfmpcreatev,
+  nsfw_shmem_mbfalloc,
+  nsfw_shmem_mbffree,
+  nsfw_shmem_mbfmplookup,
+  nsfw_shmem_mbfmprelease,
+  nsfw_shmem_spcreate,
+  nsfw_shmem_spcreatev,
+  nswf_shmem_sp_ringcreate,
+  nsfw_shmem_sprelease,
+  nsfw_shmem_sp_lookup,
+  nsfw_shmem_ringcreate,
+  nsfw_shmem_ring_lookup,
+  nsfw_shmem_ringrelease,
+  nsfw_shmem_stactic,
+  nsfw_shmem_mbuf_recycle,
+  nsfw_shmem_sp_iterator,
+  nsfw_shmem_mbuf_iterator
+};
diff --git a/src/framework/common/mem_mgr/nsfw_shmem/nsfw_shmem_mdesc.h b/src/framework/common/mem_mgr/nsfw_shmem/nsfw_shmem_mdesc.h
new file mode 100644
index 0000000..afd9e29
--- /dev/null
+++ b/src/framework/common/mem_mgr/nsfw_shmem/nsfw_shmem_mdesc.h
@@ -0,0 +1,22 @@
+/*
+*
+* 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.
+*/
+
+#ifndef _NSFW_SHMEM_MDESC_H_
+#define _NSFW_SHMEM_MDESC_H_
+
+extern nsfw_mem_ops g_shmem_ops;
+
+#endif
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);
+}
diff --git a/src/framework/common/mem_mgr/nsfw_shmem/nsfw_shmem_mng.h b/src/framework/common/mem_mgr/nsfw_shmem/nsfw_shmem_mng.h
new file mode 100644
index 0000000..f81b34a
--- /dev/null
+++ b/src/framework/common/mem_mgr/nsfw_shmem/nsfw_shmem_mng.h
@@ -0,0 +1,133 @@
+/*
+*
+* 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.
+*/
+
+#ifndef _NSFW_SHMEM_MNG_H
+#define _NSFW_SHMEM_MNG_H
+
+/*
+ * mem mgr module init
+ * para:point to nstak_fwmem_para
+ */
+i32 nsfw_shmem_init (nsfw_mem_para * para);
+
+/*
+ * mem mgr module destory
+ *
+ */
+void nsfw_shmem_destroy (void);
+
+/*
+ * create a block memory with name
+ * fw_mem_zone::stname name of memory
+ * fw_mem_zone::isize memory size
+ */
+mzone_handle nsfw_shmem_create (nsfw_mem_zone * pinfo);
+
+/*
+ *create some blocks memeory
+ */
+i32 nsfw_shmem_createv (nsfw_mem_zone * pmeminfo, i32 inum,
+                        mzone_handle * paddr_array, i32 iarray_num);
+
+/*
+ *lookup a memory
+ */
+mzone_handle nsfw_shmem_lookup (nsfw_mem_name * pname);
+
+/*release the memory*/
+i32 nsfw_shmem_release (nsfw_mem_name * pname);
+
+/*
+ *create mbuf pool
+ */
+mpool_handle nsfw_shmem_mbfmpcreate (nsfw_mem_mbfpool * pbufinfo);
+
+/*
+ *create some mbuf pool
+ */
+i32 nsfw_shmem_mbfmpcreatev (nsfw_mem_mbfpool * pmbfname, i32 inum,
+                             mpool_handle * phandle_array, i32 iarray_num);
+
+/*
+ *alloc a mbuf from mbuf pool
+ */
+mbuf_handle nsfw_shmem_mbfalloc (mpool_handle mhandle);
+
+/*
+ *release a mbuf pool
+ */
+i32 nsfw_shmem_mbffree (mbuf_handle mhandle);
+
+/*
+ *put mbuf backto mbuf pool
+ */
+i32 nsfw_shmem_mbfmprelease (nsfw_mem_name * pname);
+
+/*look up mbuf mpool*/
+mpool_handle nsfw_shmem_mbfmplookup (nsfw_mem_name * pmbfname);
+
+/*
+ *create simple pool
+ */
+mring_handle nsfw_shmem_spcreate (nsfw_mem_sppool * pmpinfo);
+
+/*
+ *create some simple pools
+ */
+i32 nsfw_shmem_spcreatev (nsfw_mem_sppool * pmpinfo, i32 inum,
+                          mring_handle * pringhandle_array, i32 iarray_num);
+
+/*
+ *create a simple pool that members are rings
+ */
+i32 nswf_shmem_sp_ringcreate (nsfw_mem_mring * prpoolinfo,
+                              mring_handle * pringhandle_array, i32 iringnum);
+
+/*
+ *release a simple pool
+ */
+i32 nsfw_shmem_sprelease (nsfw_mem_name * pname);
+
+/*
+ *look up a simple pool
+ */
+mring_handle nsfw_shmem_sp_lookup (nsfw_mem_name * pname);
+
+/*
+ *create a ring with name
+ */
+mring_handle nsfw_shmem_ringcreate (nsfw_mem_mring * pringinfo);
+
+/*
+ *look up a ring with name
+ */
+mring_handle nsfw_shmem_ring_lookup (nsfw_mem_name * pname);
+
+/*
+ *release ring
+ */
+i32 nsfw_shmem_ringrelease (nsfw_mem_name * pname);
+
+ssize_t nsfw_shmem_stactic (void *handle, nsfw_mem_struct_type type);
+
+i32 nsfw_shmem_mbuf_recycle (mpool_handle handle);
+
+i32 nsfw_shmem_sp_iterator (mpool_handle handle, u32 start, u32 end,
+                            nsfw_mem_item_fun fun, void *argv);
+i32 nsfw_shmem_mbuf_iterator (mpool_handle handle, u32 start, u32 end,
+                              nsfw_mem_item_fun fun, void *argv);
+
+#endif
diff --git a/src/framework/common/mem_mgr/nsfw_shmem/nsfw_shmem_ring.c b/src/framework/common/mem_mgr/nsfw_shmem/nsfw_shmem_ring.c
new file mode 100644
index 0000000..af46e18
--- /dev/null
+++ b/src/framework/common/mem_mgr/nsfw_shmem/nsfw_shmem_ring.c
@@ -0,0 +1,839 @@
+/*
+*
+* 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 <string.h>
+#include <common_sys_config.h>
+
+#include "common_mem_pal.h"
+#include "common_mem_pal_memconfig.h"
+#include "nstack_securec.h"
+#include "nsfw_shmem_ring.h"
+#include "nsfw_ring_fun.h"
+#include "common_mem_buf.h"
+#include "common_func.h"
+
+void
+nsfw_shmem_ring_baseaddr_query (uint64_t * rte_lowest_addr,
+                                uint64_t * rte_highest_addr)
+{
+  struct common_mem_mem_config *pMemCfg =
+    common_mem_pal_get_configuration ()->mem_config;
+  struct common_mem_memseg *PMemSegArry = pMemCfg->memseg;
+
+  *rte_lowest_addr = PMemSegArry[0].addr_64;
+  *rte_highest_addr = PMemSegArry[0].addr_64 + PMemSegArry[0].len;
+
+  int s = 1;
+
+  while (s < COMMON_MEM_MAX_MEMSEG && PMemSegArry[s].len > 0)
+    {
+      if (*rte_lowest_addr > PMemSegArry[s].addr_64)
+        {
+          *rte_lowest_addr = PMemSegArry[s].addr_64;
+        }
+
+      if (*rte_highest_addr < PMemSegArry[s].addr_64 + PMemSegArry[s].len)
+        {
+          *rte_highest_addr = PMemSegArry[s].addr_64 + PMemSegArry[s].len;
+        }
+
+      s++;
+    }
+
+}
+
+static unsigned
+nsfw_shmem_pool_node_alloc (struct nsfw_mem_ring *perfring_ptr,
+                            unsigned alloc_index, unsigned max_index,
+                            void *mz, size_t mz_len, unsigned elt_size)
+{
+  size_t alloc_size = 0;
+  unsigned offset_idx = 0;
+  NSTCP_LOGINF ("mz(%p), mz_len = 0x%x", mz, mz_len);
+
+  while (alloc_size + elt_size <= mz_len)
+    {
+      perfring_ptr->ring[alloc_index + offset_idx].data_s.ver =
+        alloc_index + offset_idx;
+      perfring_ptr->ring[alloc_index + offset_idx].data_s.val =
+        ADDR_LTOSH_EXT (mz) - ((uint64_t) perfring_ptr->Addrbase);
+      mz = (char *) mz + elt_size;
+      alloc_size += elt_size;
+      offset_idx++;
+
+      if (alloc_index + offset_idx == max_index)
+        {
+          break;
+        }
+    }
+
+  return offset_idx;
+}
+
+void
+nsfw_shmem_pool_free (struct nsfw_mem_ring *perfring_ptr)
+{
+  struct nsfw_shmem_ring_head *ptemp;
+
+  if (NULL == perfring_ptr)
+    {
+      return;
+    }
+
+  struct nsfw_shmem_ring_head *pnode =
+    (struct nsfw_shmem_ring_head *) ((char *) perfring_ptr -
+                                     sizeof (struct nsfw_shmem_ring_head));
+
+  while (pnode)
+    {
+      // phead is involved in phead->mem_zone
+      ptemp = pnode->next;
+      common_mem_memzone_free (pnode->mem_zone);
+      pnode = ptemp;
+    }
+}
+
+struct nsfw_mem_ring *
+nsfw_shmem_pool_create (const char *name, unsigned int n,
+                        unsigned int elt_size, int socket_id,
+                        unsigned char flag)
+{
+  struct nsfw_mem_ring *perfring_ptr = NULL;
+  struct common_mem_memzone *mz_mem;
+  void *mz = NULL;
+
+  /*get pool size, pool size must pow of 2 */
+  unsigned int num = common_mem_align32pow2 (n + 1);
+
+  struct nsfw_shmem_ring_head *pcur = NULL;
+  /*calculat the empty rte_perf_ring Size */
+  size_t len =
+    sizeof (struct nsfw_shmem_ring_head) + sizeof (struct nsfw_mem_ring) +
+    (size_t) num * sizeof (union RingData_U) + (size_t) num * elt_size;
+  size_t alloc_len = len;
+  unsigned int alloc_num = 0;
+  unsigned int alloc_index = 0;
+
+  size_t mz_len = 0;
+
+  unsigned int mz_index = 1;
+  char mz_name[128] = { 0 };
+  int retVal;
+  /*we'd better use `strlen(src)` or `sizeof(dst)` to explain copying length of src string.
+     it's meaningless using `sizeof(dst) - 1` to reserve 1 byte for '\0'.
+     if copying length equals to or bigger than dst length, just let STRNCPY_S() returns failure. */
+  retVal = STRNCPY_S (mz_name, sizeof (mz_name), name, sizeof (mz_name));
+
+  if (EOK != retVal)
+    {
+      NSTCP_LOGERR ("STRNCPY_S failed]ret=%d", retVal);
+      return NULL;
+    }
+
+  mz_mem = common_memzone_data_lookup_name (name);
+  NSTCP_LOGINF ("memzone data look up] n=%u,num=%u,len=%zu", n, num, len);
+
+  if (mz_mem)
+    {
+      perfring_ptr =
+        (struct nsfw_mem_ring *) ((char *) mz_mem +
+                                  sizeof (struct nsfw_shmem_ring_head));
+      return perfring_ptr;
+    }
+
+  while (alloc_len > 0)
+    {
+      if (NULL != perfring_ptr)
+        {
+          retVal =
+            SPRINTF_S (mz_name, sizeof (mz_name), "%s_%03d", name, mz_index);
+
+          if (-1 == retVal)
+            {
+              NSCOMM_LOGERR ("SPRINTF_S failed]ret=%d", retVal);
+              nsfw_shmem_pool_free (perfring_ptr);
+              return NULL;
+            }
+        }
+
+      mz_mem =
+        (struct common_mem_memzone *) common_mem_memzone_reserve (mz_name,
+                                                                  alloc_len,
+                                                                  socket_id,
+                                                                  0);
+
+      if (mz_mem == NULL)
+        {
+          mz_mem =
+            (struct common_mem_memzone *) common_mem_memzone_reserve (mz_name,
+                                                                      0,
+                                                                      socket_id,
+                                                                      0);
+        }
+
+      if (mz_mem == NULL)
+        {
+          nsfw_shmem_pool_free (perfring_ptr);
+          return NULL;
+        }
+
+      if (NULL == perfring_ptr
+          && (mz_mem->len <
+              sizeof (struct nsfw_shmem_ring_head) +
+              sizeof (struct nsfw_mem_ring) +
+              num * sizeof (union RingData_U)))
+        {
+          common_mem_memzone_free (mz_mem);
+          return NULL;
+        }
+
+      if (NULL == perfring_ptr)
+        {
+          pcur = (struct nsfw_shmem_ring_head *) ADDR_SHTOL (mz_mem->addr_64);
+          pcur->mem_zone = mz_mem;
+          pcur->next = NULL;
+
+          perfring_ptr =
+            (struct nsfw_mem_ring *) ((char *) pcur +
+                                      sizeof (struct nsfw_shmem_ring_head));
+
+          mz =
+            (void *) ((char *) perfring_ptr + sizeof (struct nsfw_mem_ring) +
+                      num * sizeof (union RingData_U));
+          mz_len =
+            mz_mem->len - sizeof (struct nsfw_shmem_ring_head) -
+            sizeof (struct nsfw_mem_ring) - num * sizeof (union RingData_U);
+
+          uint64_t rte_base_addr;
+          uint64_t rte_highest_addr;
+          nsfw_shmem_ring_baseaddr_query (&rte_base_addr, &rte_highest_addr);
+          nsfw_mem_pool_head_init (perfring_ptr, num, elt_size,
+                                   (void *) rte_base_addr, NSFW_SHMEM,
+                                   (nsfw_mpool_type) flag);
+        }
+      else
+        {
+          if (pcur)
+            {
+              pcur->next =
+                (struct nsfw_shmem_ring_head *) ADDR_SHTOL (mz_mem->addr_64);
+              pcur = pcur->next;
+              pcur->mem_zone = mz_mem;
+              pcur->next = NULL;
+
+              if (mz_mem->len < sizeof (struct nsfw_shmem_ring_head))
+                {
+                  NSCOMM_LOGERR ("mz_len error %d", mz_mem->len);
+                  nsfw_shmem_pool_free (perfring_ptr);
+                  return NULL;
+                }
+
+              mz =
+                (void *) ((char *) pcur +
+                          sizeof (struct nsfw_shmem_ring_head));
+              mz_len = mz_mem->len - sizeof (struct nsfw_shmem_ring_head);
+            }
+        }
+
+      alloc_num =
+        nsfw_shmem_pool_node_alloc (perfring_ptr, alloc_index, num, mz,
+                                    mz_len, elt_size);
+      alloc_index += alloc_num;
+
+      if (alloc_index >= num)
+        {
+          break;
+        }
+
+      // second time allocate should not containd all ring head
+      alloc_len =
+        (size_t) (num - alloc_index) * elt_size +
+        sizeof (struct nsfw_shmem_ring_head);
+      mz_index++;
+    }
+
+  return perfring_ptr;
+}
+
+/*ring create*/
+struct nsfw_mem_ring *
+nsfw_shmem_ring_create (const char *name, unsigned int n, int socket_id,
+                        unsigned char flag)
+{
+  struct nsfw_mem_ring *perfring_ptr;
+  struct common_mem_memzone *mz;
+  uint64_t rte_base_addr;
+  uint64_t rte_highest_addr;
+
+  unsigned int num = common_mem_align32pow2 (n);
+
+  mz =
+    (struct common_mem_memzone *) common_mem_memzone_reserve (name,
+                                                              sizeof (struct
+                                                                      nsfw_mem_ring)
+                                                              +
+                                                              num *
+                                                              sizeof (union
+                                                                      RingData_U),
+                                                              socket_id, 0);
+
+  if (mz == NULL)
+    {
+      return NULL;
+    }
+
+  perfring_ptr = mz->addr;
+
+  nsfw_shmem_ring_baseaddr_query (&rte_base_addr, &rte_highest_addr);
+  nsfw_mem_ring_init (perfring_ptr, num, (void *) rte_base_addr, NSFW_SHMEM,
+                      flag);
+
+  return perfring_ptr;
+}
+
+/*
+this is a  multi thread/process enqueue function, please pay attention to the bellow point
+1. while Enqueue corrupt,  we may lose one element; because no one to add the Head
+*/
+int
+nsfw_shmem_ring_mp_enqueue (struct nsfw_mem_ring *ring, void *box)
+{
+  union RingData_U expectPostVal;
+  union RingData_U curVal;
+  unsigned int tmpHead;
+  unsigned int tmpTail;
+  unsigned int CurHead = ring->prod.head;
+  unsigned int mask = ring->mask;
+  unsigned int size = ring->size;
+  void *prmBox = NULL;
+
+  prmBox = (void *) ADDR_LTOSH_EXT (box);
+
+  /*do box range check */
+  if ((char *) prmBox <= (char *) ring->Addrbase
+      || (char *) prmBox > (char *) ring->Addrbase + PERFRING_ADDR_RANGE)
+    {
+      /*invalid addr of box, can't put in rte_perf_ring, maybe should set a errno here */
+      return -1;
+    }
+
+  do
+    {
+      /*
+         if the ring is Full return directly; this not a exact check, cause we made tail++ after dequeue success.
+         the thing we could make sure is ring[ring->Tail&mask] already dequeue
+       */
+      tmpTail = ring->cons.tail;
+
+      if (tmpTail + size - CurHead == 0)
+        {
+          /*
+             here we give enque a chance to recorrect the Tail,   if tail not has Data let tail++
+           */
+          if (ring->ring[tmpTail & mask].data_s.val == 0)
+            {
+              (void) __sync_bool_compare_and_swap (&ring->cons.tail, tmpTail,
+                                                   tmpTail + 1);
+            }
+          else
+            {
+              return 0;
+            }
+        }
+
+      /*
+         the old version of ring->ring[CurHead&mask] must CurHead - size, which enqueue set to this pos lasttime
+         & the val must already dequeue. otherwise this pos can't enqueue;
+       */
+      expectPostVal.data_l =
+        (((unsigned long long) (CurHead - size)) << VALUE_LEN);
+
+      /*
+         the new version of ring->ring[CurHead&mask] must CurHead, which enqueue set to this pos this time.
+       */
+      curVal.data_l =
+        ((((unsigned long long) CurHead) << VALUE_LEN) |
+         ((char *) prmBox - (char *) ring->Addrbase));
+      if (ring->ring[CurHead & mask].data_s.ver == expectPostVal.data_s.ver
+          && __sync_bool_compare_and_swap (&ring->ring[CurHead & mask].data_l,
+                                           expectPostVal.data_l,
+                                           curVal.data_l))
+        {
+          /*
+             enqueue success, add Head Value now
+             here we using  CAS set instead __sync_fetch_and_add(&ring->Head, 1) to assume that, if one process enque sucess && been killed before
+             add Head, other process can recorrect the Head Value;
+             one more thing the direction of Tail must been add-direction, so we using the condition (ring->Head - CurHead >0x80000000);
+             while many thread do enque at same time, Head may not correct,exp:
+             thread A get old head 10, thread A want set head to 11
+             thread B get old head 10, thread B want set head to 12
+             thread A do CAS && thread B do CAS at same time, thread A do CAS success;
+             the result of head is 11, but the correct Value should be 12;
+
+             then thread C get old head 11, thread C will set head to 13[cause pos 12 already has value, thread C will skill 12],
+             the head will be recorrect by thread C.
+             if no thread C, thread A& B are the last enque thread; the head must recorrect by the deque function.
+           */
+          tmpHead = ring->prod.head;
+
+          if (0 == (CurHead & 0x03) && tmpHead - CurHead > 0x80000000)
+            {
+              (void) __sync_bool_compare_and_swap (&ring->prod.head, tmpHead,
+                                                   CurHead + 1);
+            }
+
+          break;
+        }
+
+      /*
+         CurHead++ here;
+         may be cpu slice is end here; while re-sched CurHead < ring->Tail < ring->Head; to avoid multi try
+         we using a cmp & CurHead++  instead CurHead++  directly.
+         if using CurHead++ will amplify the probability of ABA problem
+       */
+      /*CurHead++; */
+      tmpHead = ring->prod.head;
+      CurHead = CurHead - tmpHead < mask - 1 ? CurHead + 1 : tmpHead;
+    }
+  while (1);
+
+  return 1;
+}
+
+/*
+   this is a  single thread/process enqueue function
+ */
+int
+nsfw_shmem_ring_sp_enqueue (struct nsfw_mem_ring *ring, void *box)
+{
+  union RingData_U texpectPostVal;
+  union RingData_U curVal;
+  unsigned int tmpTail;
+  unsigned int CurHead = ring->prod.head;
+  unsigned int mask = ring->mask;
+  unsigned int uisize = ring->size;
+  void *prmBox = NULL;
+
+  prmBox = (void *) ADDR_LTOSH_EXT (box);
+
+  if ((char *) prmBox <= (char *) ring->Addrbase
+      || (char *) prmBox > (char *) ring->Addrbase + PERFRING_ADDR_RANGE)
+    {
+      return -1;
+    }
+
+  do
+    {
+      tmpTail = ring->cons.tail;
+      if (tmpTail + uisize - CurHead == 0)
+        {
+          /*
+           *here we give enque a chance to recorrect the Tail,   if tail not has Data let tail++
+           */
+          if (ring->ring[tmpTail & mask].data_s.val == 0)
+            {
+              (void) __sync_bool_compare_and_swap (&ring->cons.tail, tmpTail,
+                                                   tmpTail + 1);
+            }
+          else
+            {
+              return 0;
+            }
+        }
+      texpectPostVal.data_l =
+        (((unsigned long long) (CurHead - uisize)) << VALUE_LEN);
+
+      curVal.data_l =
+        ((((unsigned long long) CurHead) << VALUE_LEN) |
+         ((char *) prmBox - (char *) ring->Addrbase));
+
+      if (ring->ring[CurHead & mask].data_l == texpectPostVal.data_l)
+        {
+          ring->ring[CurHead & mask].data_l = curVal.data_l;
+          ring->prod.head = CurHead + 1;
+          break;
+        }
+
+      CurHead++;
+    }
+  while (1);
+  return 1;
+}
+
+/*this is a  multi thread/process dequeue function, please pay attention to the bellow point
+*/
+int
+nsfw_shmem_ring_mc_dequeue (struct nsfw_mem_ring *ring, void **box)
+{
+  unsigned int CurTail;
+  unsigned int tmpTail;
+  unsigned int tmpHead;
+  unsigned int mask = ring->mask;
+  union RingData_U curNullVal;
+  union RingData_U ExcpRingVal;
+
+  CurTail = ring->cons.tail;
+  do
+    {
+      /*if ring is empty return directly */
+      tmpHead = ring->prod.head;
+
+      if (CurTail == tmpHead)
+        {
+          /*
+             here we give deque a chance to recorrect the Head,   if head has Data let Head++
+           */
+          if (ring->ring[tmpHead & mask].data_s.val != 0)
+            {
+              (void) __sync_bool_compare_and_swap (&ring->prod.head, tmpHead,
+                                                   tmpHead + 1);
+            }
+          else
+            {
+              return 0;
+            }
+        }
+      curNullVal.data_l = (((unsigned long long) CurTail) << VALUE_LEN);
+      ExcpRingVal = ring->ring[CurTail & mask];
+      /*
+       *the version of ring->ring[CurTail&mask] must CurTail&0xFFFFFF
+       */
+      if ((curNullVal.data_s.ver == ExcpRingVal.data_s.ver)
+          && (ExcpRingVal.data_s.val)
+          && __sync_bool_compare_and_swap (&ring->ring[CurTail & mask].data_l,
+                                           ExcpRingVal.data_l,
+                                           curNullVal.data_l))
+        {
+
+          *box =
+            ADDR_SHTOL (((char *) ring->Addrbase + ExcpRingVal.data_s.val));
+
+          /*
+             enqueue success, add Tail Value now
+             here we using  CAS set instead __sync_fetch_and_add(&ring->Tail, 1) to assume that, if one process dequeue sucess && been killed before
+             add Tail, other process can recorrect the Tail Value;
+             one more thing the direction of Tail must been add-direction, so we using the condition (rlTail - CurTail >0x80000000);
+             while multi CAS done the result value of CurTail may not correct, but we don't care, it will be recorrect while next deque done.
+
+             avg CAS cost 200-300 Cycles, so we using cache loop to instead some CAS;[head&tail not exact guide, so no need Do CAS evertime]
+             here we using 0 == (CurTail&0x11) means we only do CAS while head/tail low bit is 0x11; four times do one CAS.
+           */
+          tmpTail = ring->cons.tail;
+
+          if (0 == (CurTail & 0x03) && tmpTail - CurTail > 0x80000000)
+            {
+              (void) __sync_bool_compare_and_swap (&ring->cons.tail, tmpTail,
+                                                   CurTail + 1);
+            }
+          break;
+        }
+
+      /*
+         CurTail++ here;
+         may be  cpu slice is end here; while re-sched CurTail < ring->Tail < ring->Head; to avoid multi try
+         we using a cmp & CurTail++  instead CurTail++  directly.
+         if using CurTail++ will amplify the probability of ABA problem
+       */
+      /*CurTail++; */
+      tmpTail = ring->cons.tail;
+      CurTail = CurTail - tmpTail < mask - 1 ? CurTail + 1 : tmpTail;
+    }
+  while (1);
+
+  return 1;
+}
+
+/*
+   this is enhanced mc_ring_dequeue, support dequeue multi element one time.
+*/
+int
+nsfw_shmem_ring_mc_dequeuev (struct nsfw_mem_ring *ring, void **box,
+                             unsigned int n)
+{
+  unsigned int uiCurTail;
+  unsigned int tmpTail;
+  unsigned int tmpHead;
+  unsigned int uimask = ring->mask;
+  union RingData_U curNullVal;
+  union RingData_U ExcpRingVal;
+  unsigned int deqNum = 0;
+  uiCurTail = ring->cons.tail;
+  do
+    {
+      /*if ring is empty return directly */
+      tmpHead = ring->prod.head;
+      if (uiCurTail == tmpHead)
+        {
+          /*
+             here we give deque a chance to recorrect the Head,   if head has Data let Head++;
+             here must done to avoid some msg can't deque.
+           */
+          if (deqNum == 0 && ring->ring[tmpHead & uimask].data_s.val != 0)
+            {
+              (void) __sync_bool_compare_and_swap (&ring->prod.head, tmpHead,
+                                                   tmpHead + 1);
+            }
+          else
+            {
+              return deqNum;
+            }
+        }
+
+      curNullVal.data_l = (((unsigned long long) uiCurTail) << VALUE_LEN);
+      ExcpRingVal = ring->ring[uiCurTail & uimask];
+
+      /*
+       *the version of ring->ring[CurTail&mask] must CurTail&0xFFFFFF
+       */
+      if ((curNullVal.data_s.ver == ExcpRingVal.data_s.ver)
+          && (ExcpRingVal.data_s.val)
+          && __sync_bool_compare_and_swap (&ring->
+                                           ring[uiCurTail & uimask].data_l,
+                                           ExcpRingVal.data_l,
+                                           curNullVal.data_l))
+        {
+
+          box[deqNum] =
+            ADDR_SHTOL (((char *) ring->Addrbase + ExcpRingVal.data_s.val));
+
+          /*
+             enqueue success, add Tail Value now
+             here we using  CAS set instead __sync_fetch_and_add(&ring->Tail, 1) to assume that, if one process dequeue sucess && been killed before
+             add Tail, other process can recorrect the Tail Value;
+             one more thing the direction of Tail must been add-direction, so we using the condition (rlTail - CurTail >0x80000000);
+
+             avg CAS cost 200-300 Cycles, so we using cache loop to instead some CAS;[head&tail not exact guide, so no need Do CAS evertime]
+             here we using 0 == (CurTail&0x11) means we only do CAS while head/tail low bit is 0x11; four times do one CAS.
+           */
+          tmpTail = ring->cons.tail;
+
+          if (0 == (uiCurTail & 0x03) && tmpTail - uiCurTail > 0x80000000)
+            {
+              (void) __sync_bool_compare_and_swap (&ring->cons.tail, tmpTail,
+                                                   uiCurTail + 1);
+            }
+
+          deqNum++;
+        }
+
+      /*
+         CurTail++ here;
+         may be  cpu slice is end here; while re-sched CurTail < ring->Tail < ring->Head; to avoid multi try
+         we using a cmp & CurTail++  instead CurTail++  directly.
+         if using CurTail++ will amplify the probability of ABA problem
+       */
+      /*CurTail++; */
+      tmpTail = ring->cons.tail;
+      uiCurTail = uiCurTail - tmpTail < uimask - 1 ? uiCurTail + 1 : tmpTail;
+
+    }
+  while (n > deqNum);
+
+  return deqNum;
+}
+
+/*
+   this is enhanced mc_ring_dequeue, support dequeue multi element one time.
+*/
+int
+nsfw_shmem_ring_sc_dequeue (struct nsfw_mem_ring *ring, void **box)
+{
+  unsigned int CurTail;
+  unsigned int mask = ring->mask;
+  union RingData_U curNullVal;
+  union RingData_U ExcpRingVal;
+  unsigned int uitmpHead;
+
+  CurTail = ring->cons.tail;
+
+  do
+    {
+      /*if ring is empty return directly */
+      uitmpHead = ring->prod.head;
+      if (CurTail == uitmpHead)
+        {
+          /*
+             here we give deque a chance to recorrect the Head,   if head has Data let Head++
+           */
+          if (ring->ring[uitmpHead & mask].data_s.val != 0)
+            {
+              (void) __sync_bool_compare_and_swap (&ring->prod.head,
+                                                   uitmpHead, uitmpHead + 1);
+            }
+          else
+            {
+              return 0;
+            }
+        }
+      curNullVal.data_l = (((unsigned long long) CurTail) << VALUE_LEN);
+      ExcpRingVal = ring->ring[CurTail & mask];
+
+      if ((curNullVal.data_s.ver == ExcpRingVal.data_s.ver)
+          && (ExcpRingVal.data_s.val))
+        {
+          ring->ring[CurTail & mask].data_l = curNullVal.data_l;
+
+          *box =
+            ADDR_SHTOL (((char *) ring->Addrbase + ExcpRingVal.data_s.val));
+
+          ring->cons.tail = CurTail + 1;
+          break;
+        }
+
+      CurTail++;
+    }
+  while (1);
+
+  return 1;
+}
+
+/*
+   this is a single thread/process dequeue function
+*/
+int
+nsfw_shmem_ring_sc_dequeuev (struct nsfw_mem_ring *ring, void **box,
+                             unsigned int n)
+{
+  unsigned int CurTail;
+  unsigned int tmpHead;
+  unsigned int mask = ring->mask;
+  union RingData_U curNullVal;
+  union RingData_U ExcpRingVal;
+  unsigned int usdeqNum = 0;
+
+  CurTail = ring->cons.tail;
+
+  do
+    {
+      /*if ring is empty return directly */
+      tmpHead = ring->prod.head;
+      if (CurTail == tmpHead)
+        {
+          /*
+             here we give deque a chance to recorrect the Head,   if head has Data let Head++;
+             here must done to avoid some msg can't deque.
+           */
+          if (usdeqNum == 0 && ring->ring[tmpHead & mask].data_s.val != 0)
+            {
+              (void) __sync_bool_compare_and_swap (&ring->prod.head, tmpHead,
+                                                   tmpHead + 1);
+            }
+          else
+            {
+              return usdeqNum;
+            }
+        }
+      curNullVal.data_l = (((unsigned long long) CurTail) << VALUE_LEN);
+      ExcpRingVal = ring->ring[CurTail & mask];
+
+      /*
+         the version of ring->ring[CurTail&mask] must CurTail&0xFFFFFF
+       */
+      if ((curNullVal.data_s.ver == ExcpRingVal.data_s.ver)
+          && (ExcpRingVal.data_s.val))
+        {
+          ring->ring[CurTail & mask].data_l = curNullVal.data_l;
+
+          box[usdeqNum] =
+            ADDR_SHTOL (((char *) ring->Addrbase + ExcpRingVal.data_s.val));
+
+          ring->cons.tail = CurTail + 1;
+          usdeqNum++;
+        }
+
+      CurTail++;
+    }
+  while (n > usdeqNum);
+
+  return usdeqNum;
+}
+
+/* nstack just using one thread, for performance using que not support multi thread*/
+int
+nsfw_shmem_ring_singlethread_enqueue (struct nsfw_mem_ring *ring, void *box)
+{
+  u32 head = 0;
+  void *prmBox = NULL;
+
+  /*if queue is full, just return 0 */
+  if (ring->prod.head >= (ring->size + ring->cons.tail))
+    {
+      return 0;
+    }
+
+  prmBox = (void *) ADDR_LTOSH_EXT (box);
+
+  head = ring->prod.head;
+  ring->prod.head = head + 1;
+  ring->ring[head & ring->mask].data_s.ver = head;
+  ring->ring[head & ring->mask].data_s.val =
+    (char *) prmBox - (char *) ring->Addrbase;
+  return 1;
+}
+
+/* nstack just using one thread, for performance using que not support multi thread*/
+int
+nsfw_shmem_ring_singlethread_dequeue (struct nsfw_mem_ring *ring, void **box)
+{
+  u32 tail = 0;
+
+  /* if all entries are dequed return 0 */
+  if (unlikely (ring->prod.head == ring->cons.tail))
+    {
+      return 0;
+    }
+
+  tail = ring->cons.tail;
+  *box =
+    ADDR_SHTOL ((char *) ring->Addrbase +
+                ring->ring[tail & ring->mask].data_s.val);
+  ring->ring[tail & ring->mask].data_s.val = 0;
+  ring->ring[tail & ring->mask].data_s.ver = tail;
+  ring->cons.tail++;
+  return 1;
+}
+
+/*    nstack just using one thread, for performance using que not support multi thread*/
+int
+nsfw_shmem_ring_singlethread_dequeuev (struct nsfw_mem_ring *ring, void **box,
+                                       unsigned int n)
+{
+  u32 tail = 0;
+  u32 num = 0;
+
+  while (num < n)
+    {
+      tail = ring->cons.tail;
+
+      /* if all entries are dequed return 0 */
+      if (unlikely (ring->prod.head == ring->cons.tail))
+        {
+          return num;
+        }
+
+      ring->cons.tail = tail + 1;
+
+      box[num] =
+        ADDR_SHTOL ((char *) ring->Addrbase +
+                    ring->ring[tail & ring->mask].data_s.val);
+
+      ring->ring[tail & ring->mask].data_s.val = 0;
+      ring->ring[tail & ring->mask].data_s.ver = tail;
+      num++;
+    }
+
+  return num;
+}
diff --git a/src/framework/common/mem_mgr/nsfw_shmem/nsfw_shmem_ring.h b/src/framework/common/mem_mgr/nsfw_shmem/nsfw_shmem_ring.h
new file mode 100644
index 0000000..15cd1dd
--- /dev/null
+++ b/src/framework/common/mem_mgr/nsfw_shmem/nsfw_shmem_ring.h
@@ -0,0 +1,60 @@
+/*
+*
+* 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.
+*/
+
+#ifndef _NSFW_SHMEM_RING_H_
+#define _NSFW_SHMEM_RING_H_
+
+#include <stdint.h>
+
+#include "common_func.h"
+
+struct nsfw_shmem_ring_head
+{
+  struct common_mem_memzone *mem_zone;
+  struct nsfw_shmem_ring_head *next;
+  unsigned int uireserv[4];
+};
+
+void nsfw_shmem_ring_baseaddr_query (uint64_t * rte_lowest_addr,
+                                     uint64_t * rte_highest_addr);
+struct nsfw_mem_ring *nsfw_shmem_pool_create (const char *name,
+                                              unsigned int n,
+                                              unsigned int elt_size,
+                                              int socket_id,
+                                              unsigned char flag);
+struct nsfw_mem_ring *nsfw_shmem_ring_create (const char *name,
+                                              unsigned int n, int socket_id,
+                                              unsigned char flag);
+
+void nsfw_shmem_pool_free (struct nsfw_mem_ring *perfring_ptr);
+
+void nsfw_shmem_ring_reset (struct nsfw_mem_ring *ring, unsigned char flag);
+int nsfw_shmem_ring_mp_enqueue (struct nsfw_mem_ring *ring, void *box);
+int nsfw_shmem_ring_sp_enqueue (struct nsfw_mem_ring *ring, void *box);
+int nsfw_shmem_ring_mc_dequeue (struct nsfw_mem_ring *ring, void **box);
+int nsfw_shmem_ring_mc_dequeuev (struct nsfw_mem_ring *ring, void **box,
+                                 unsigned int n);
+int nsfw_shmem_ring_sc_dequeue (struct nsfw_mem_ring *ring, void **box);
+int nsfw_shmem_ring_sc_dequeuev (struct nsfw_mem_ring *ring, void **box,
+                                 unsigned int n);
+int nsfw_shmem_ring_singlethread_enqueue (struct nsfw_mem_ring *ring,
+                                          void *box);
+int nsfw_shmem_ring_singlethread_dequeue (struct nsfw_mem_ring *ring,
+                                          void **box);
+int nsfw_shmem_ring_singlethread_dequeuev (struct nsfw_mem_ring *ring,
+                                           void **box, unsigned int n);
+
+#endif /*_NSFW_SHMEM_RING_H_*/