/* * * 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 #include #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 nstack_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 modules 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 length of name must be less than NSFW_MEM_APPNAME_LENGTH. * 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_create, (pinfo)); NSCOMM_LOGINF ("mem create fail] memtype=%d, name=%s, size=%zu", pinfo->stname.entype, pinfo->stname.aname, pinfo->length); return NULL; } /***************************************************************************** * Prototype : nsfw_mem_zone_createv * Description : create some memory blocks * note : 1. the length of name must be less than NSFW_MEM_APPNAME_LENGTH. * 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 length of name must be less than NSFW_MEM_APPNAME_LENGTH. * 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 _ 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 length must be less than NSFW_MEM_APPNAME_LENGTH. * 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 length of name must be less than NSFW_MEM_APPNAME_LENGTH. * 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 _ 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 length of name must be less than NSFW_MEM_APPNAME_LENGTH. * 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 length of name must be less than NSFW_MEM_APPNAME_LENGTH. * 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 length of name must be less than NSFW_MEM_APPNAME_LENGTH. * 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 length of name must be less than NSFW_MEM_APPNAME_LENGTH. * 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 length of name must be less than NSFW_MEM_APPNAME_LENGTH. * 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 length of name must be less than NSFW_MEM_APPNAME_LENGTH. * 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 _ 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 length of name must be less than NSFW_MEM_APPNAME_LENGTH. * 2. shared memory ring (NSFW_SHMEM) just can put a pointer 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 length of name must be less than NSFW_MEM_APPNAME_LENGTH. * 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 _ 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 length of name must be less than NSFW_MEM_APPNAME_LENGTH * 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 length 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 length of string print, 0 or -1 maybe err happen * Calls : * Called By : *****************************************************************************/ i32 nsfw_mem_dfx_ring_print (mring_handle mhandle, char *pbuf, int length) { struct nsfw_mem_ring *temp = (struct nsfw_mem_ring *) mhandle; u32 head = 0; u32 tail = 0; int ret = 0; if ((!temp) || (!pbuf) || (length <= 0)) { return 0; } head = temp->prod.head; tail = temp->cons.tail; ret = SPRINTF_S (pbuf, length, "[.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; }