diff options
Diffstat (limited to 'src/framework/lib_common_mem')
| -rw-r--r-- | src/framework/lib_common_mem/common_api.c | 325 | ||||
| -rw-r--r-- | src/framework/lib_common_mem/common_buf.c | 260 | ||||
| -rw-r--r-- | src/framework/lib_common_mem/common_func.c | 205 |
3 files changed, 790 insertions, 0 deletions
diff --git a/src/framework/lib_common_mem/common_api.c b/src/framework/lib_common_mem/common_api.c new file mode 100644 index 0000000..b535ee6 --- /dev/null +++ b/src/framework/lib_common_mem/common_api.c @@ -0,0 +1,325 @@ +/* +* +* 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_mem_api.h" +#include "common_mem_pal.h" +#include "nstack_log.h" +#include "nstack_securec.h" +#include "common_func.h" + +void +sys_sem_init_v2 (sys_sem_t_v2 sem) +{ + sem->locked = 1; +} + +/** Returns the current time in milliseconds, + * may be the same as sys_jiffies or at least based on it. */ +long +sys_now (void) +{ + struct timespec now; + + if (unlikely (0 != clock_gettime (CLOCK_MONOTONIC, &now))) + { + NSCOMM_LOGERR ("Failed to get time, errno = %d", errno); + } + + return 1000 * now.tv_sec + now.tv_nsec / 1000000; +} + +long +sys_jiffies (void) +{ + return sys_now (); +} + +err_t +sys_sem_new_v2 (sys_sem_t_v2 * sem, u8_t isUnLockd) +{ + int retVal; + if (!sem) + { + return -1; + } + *sem = malloc (sizeof (common_mem_spinlock_t)); + + if (NULL == *sem) + { + return -1; + } + else + { + retVal = + MEMSET_S (*sem, sizeof (common_mem_spinlock_t), 0, + sizeof (common_mem_spinlock_t)); + if (EOK != retVal) + { + NSCOMM_LOGERR ("MEMSET_S failed]ret=%d", retVal); + free (*sem); + *sem = NULL; + return -1; + } + common_mem_spinlock_init (*sem); + } + + if (!isUnLockd) + { + common_mem_spinlock_lock (*sem); + } + + return 0; +} + +void +sys_sem_free_v2 (sys_sem_t_v2 * sem) +{ + if ((sem != NULL) && (*sem != NULL)) + { + free (*sem); + *sem = NULL; + } + else + { + } +} + +void +sys_sem_signal_v2 (sys_sem_t_v2 * sem) +{ + common_mem_spinlock_unlock (*sem); +} + +void +sys_sem_signal_s_v2 (sys_sem_t_v2 sem) +{ + common_mem_spinlock_unlock (sem); +} + +u32_t +sys_arch_sem_trywait_v2 (sys_sem_t_v2 * sem) +{ + return (u32_t) common_mem_spinlock_trylock (*sem); +} + +u32_t +sys_arch_sem_wait_v2 (sys_sem_t_v2 * pstsem) +{ + common_mem_spinlock_lock (*pstsem); + return 0; +} + +u32_t +sys_arch_sem_wait_s_v2 (sys_sem_t_v2 sem) +{ + common_mem_spinlock_lock (sem); + return 0; +} + +volatile pid_t g_sys_host_pid = SYS_HOST_INITIAL_PID; + +/***************************************************************************** +* Prototype : get_exec_name_by_pid +* Description : get exec name by pid +* Input : pid_t pid +* char *task_name +* Output : None +* Return Value : void +* Calls : +* Called By : +*****************************************************************************/ +void +get_exec_name_by_pid (pid_t pid, char *task_name, int task_name_len) +{ + int retVal; + char path[READ_FILE_BUFLEN] = { 0 }; + char buf[READ_FILE_BUFLEN] = { 0 }; + + retVal = SPRINTF_S (path, sizeof (path), "/proc/%d/status", pid); + if (-1 == retVal) + { + NSCOMM_LOGERR ("SPRINTF_S failed]ret=%d", retVal); + return; + } + + FILE *fp = fopen (path, "r"); + if (NULL != fp) + { + if (fgets (buf, READ_FILE_BUFLEN - 1, fp) == NULL) + { + fclose (fp); + return; + } + fclose (fp); + +#ifdef SECUREC_LIB + retVal = SSCANF_S (buf, "%*s %s", task_name, task_name_len); +#else + retVal = SSCANF_S (buf, "%*s %s", task_name); +#endif + + if (1 != retVal) + { + NSSOC_LOGERR ("SSCANF_S failed]ret=%d", retVal); + return; + } + } +} + +pid_t +get_hostpid_from_file_one_time (u32_t pid) +{ + int retVal; + char path[READ_FILE_BUFLEN] = { 0 }; + char buf[READ_FILE_BUFLEN] = { 0 }; + char fmt[READ_FILE_BUFLEN] = { 0 }; + char out[READ_FILE_BUFLEN] = { 0 }; + char task_name[BUF_SIZE_FILEPATH] = { 0 }; + pid_t hostpid = SYS_HOST_INITIAL_PID; + get_exec_name_by_pid (pid, task_name, BUF_SIZE_FILEPATH); + + retVal = SPRINTF_S (fmt, sizeof (fmt), "%s%s", task_name, " (%s"); + if (-1 == retVal) + { + NSCOMM_LOGERR ("SPRINTF_S failed]ret=%d", retVal); + return hostpid; + } + retVal = SPRINTF_S (path, sizeof (path), "/proc/%d/sched", pid); + if (-1 == retVal) + { + NSCOMM_LOGERR ("SPRINTF_S failed]ret=%d", retVal); + return hostpid; + } + FILE *fp = fopen (path, "r"); + if (NULL != fp) + { + if (fgets (buf, READ_FILE_BUFLEN - 1, fp) == NULL) + { + fclose (fp); + return hostpid; + } + fclose (fp); + /* Compiler needs "fmt" to be like "%s%s" to + understand. But we have "fmt" already prepared and used here. It can + be suppressed, not an issue + */ +#pragma GCC diagnostic ignored "-Wformat-nonliteral" + retVal = SSCANF_S (buf, fmt, out, READ_FILE_BUFLEN); + if (-1 == retVal) + { + NSPOL_LOGERR ("SSCANF_S failed]ret=%d", retVal); + return hostpid; + } + } + + hostpid = (pid_t) strtol (out, NULL, 0); + if (hostpid == 0) + { + hostpid = 1; + } + + return hostpid; +} + +#define MAX_GET_PID_TIME 10 +pid_t +get_hostpid_from_file (u32_t pid) +{ + pid_t ret_pid = SYS_HOST_INITIAL_PID; + int i = 0; + ret_pid = get_hostpid_from_file_one_time (pid); + while (0 == ret_pid || ret_pid == SYS_HOST_INITIAL_PID) + { + i++; + if (i > MAX_GET_PID_TIME) + { + NSFW_LOGERR ("get pid failed]pid=%u,hostpid=%d", pid, ret_pid); + break; + } + sys_sleep_ns (0, 5000000); + ret_pid = get_hostpid_from_file_one_time (pid); + } + + return ret_pid; +} + +/***************************************************************************** +* Prototype : get_hostpid_from_file +* Description : get host pid by sub namespace pid in docker +* Input : uint32_t pid +* Output : None +* Return Value : uint32_t +* Calls : +* Called By : +*****************************************************************************/ +pid_t +sys_get_hostpid_from_file (pid_t pid) +{ + g_sys_host_pid = get_hostpid_from_file (pid); + NSCOMM_LOGDBG ("ok]cur pid=%d, input pid=%d", g_sys_host_pid, pid); + return g_sys_host_pid; +} + +pid_t +updata_sys_pid () +{ + g_sys_host_pid = SYS_HOST_INITIAL_PID; + return get_sys_pid (); +} + +/***************************************************************************** +* Prototype : get_pid_namespace +* Description : Get namespace of pid +* Input : uint32_t pid +* Output : None +* Return Value : uint64_t +* Calls : +* Called By : +*****************************************************************************/ +uint64_t +get_pid_namespace (pid_t pid) +{ + char buf[BUF_SIZE_FILEPATH] = { 0 }; + char path[BUF_SIZE_FILEPATH] = { 0 }; + const char *pstart; + int ret = 0; + if (!pid) + { + NSSOC_LOGERR ("Pid is zero!"); + return 0; + } + + ret = + SNPRINTF_S (path, sizeof (path), sizeof (path) - 1, "/proc/%d/ns/pid", + pid); + if (-1 == ret) + { + NSSOC_LOGERR ("SNPRINTF_S failed]ret=%d", ret); + return 0; + } + + ret = readlink (path, buf, sizeof (buf) - 1); + if (ret <= (int) sizeof (STR_PID)) + { + NSSOC_LOGERR ("readlink pid ns file error]ret=%d", ret); + return 0; + } + + buf[ret - 1] = 0; + pstart = &(buf[sizeof (STR_PID)]); + return strtoull (pstart, NULL, 10); +} diff --git a/src/framework/lib_common_mem/common_buf.c b/src/framework/lib_common_mem/common_buf.c new file mode 100644 index 0000000..523ce54 --- /dev/null +++ b/src/framework/lib_common_mem/common_buf.c @@ -0,0 +1,260 @@ +/* +* +* 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 <stdio.h> +#include <stdlib.h> +#include <stdint.h> +#include <stdarg.h> +#include <inttypes.h> +#include <errno.h> +#include <ctype.h> +#include <sys/queue.h> + +#include "common_mem_base_type.h" + +#include "common_mem_common.h" + +#include "common_mem_memzone.h" + +#include "common_mem_pal.h" + +#include "common_mem_mempool.h" +#include "common_mem_buf.h" + +#include "nstack_log.h" +#include "nstack_securec.h" + +#include "common_func.h" +#include "common_pal_bitwide_adjust.h" + +#define LOG_ERR 0 +#define LOG_WARN 1 +#define LOG_INFO 2 +#define LOG_DEBUG 3 +#define LOG_MAX 4 + +#define COMMON_LOG_PRINT(leve, fmt, args...) \ + if (leve <= log_levl) NSCOMM_LOGERR("===>[COMMON]"fmt, ##args); \ + +#define COMMON_PANIC(fmt) \ + NSCOMM_LOGERR("==>[COMMON_PANIC]"fmt); \ + common_dump_stack(); \ + +#define PARA1_SET(argv, tempargv, Index, para1) do {\ + retVal = STRCPY_S(tempargv[Index], PATA_STRLENT, para1);\ + if (retVal != EOK)\ + {\ + NSCOMM_LOGERR("STRCPY_S failed]ret=%d", retVal);\ + return DMM_MBUF_RET_ERR;\ + }\ + argv[Index] = tempargv[Index]; \ + Index ++; } while (0) + +#define PARA2_SET(argv, tempargv, Index, para1, para2) do {\ + retVal = STRCPY_S(tempargv[Index], PATA_STRLENT, para1); \ + if (retVal != EOK)\ + {\ + NSCOMM_LOGERR("STRCPY_S failed]ret=%d", retVal);\ + return DMM_MBUF_RET_ERR;\ + }\ + argv[Index] = tempargv[Index]; \ + Index++; \ + retVal = STRCPY_S(tempargv[Index], PATA_STRLENT, para2); \ + if (retVal != EOK)\ + {\ + NSCOMM_LOGERR("STRCPY_S failed]ret=%d", retVal);\ + return DMM_MBUF_RET_ERR;\ + }\ + argv[Index] = tempargv[Index]; \ + Index ++; } while (0) + +#define PATA_STRLENT 64 +#define PATA_NUM_MAX 12 + +int log_levl = LOG_INFO; + +int +nscomm_pal_module_init (common_mem_pal_module_info * pinfo) +{ + char tempargv[PATA_NUM_MAX][PATA_STRLENT]; + char *argv[PATA_NUM_MAX]; + char tempbuf[PATA_STRLENT]; + unsigned int Index = 0; + int ioffset = 0; + int agindex = 0; + int intmask = 0; + int retVal; + retVal = MEMSET_S (tempargv, sizeof (tempargv), '\0', sizeof (tempargv)); + if (EOK != retVal) + { + NSCOMM_LOGERR ("MEMSET_S failed]ret=%d", retVal); + return DMM_MBUF_RET_ERR; + } + retVal = MEMSET_S (argv, sizeof (argv), 0, sizeof (argv)); + if (EOK != retVal) + { + NSCOMM_LOGERR ("MEMSET_S failed]ret=%d", retVal); + return DMM_MBUF_RET_ERR; + } + if (NULL == pinfo) + { + PARA1_SET (argv, tempargv, agindex, "nStackMain"); + PARA2_SET (argv, tempargv, agindex, "-c", "0x1"); + PARA2_SET (argv, tempargv, agindex, "-n", "4"); + PARA2_SET (argv, tempargv, agindex, "-m", "2048"); + PARA1_SET (argv, tempargv, agindex, "--huge-dir=/mnt/nstackhuge"); + PARA1_SET (argv, tempargv, agindex, "--proc-type=primary"); + } + else + { + PARA1_SET (argv, tempargv, agindex, "nStackMain"); + + /*[DTS2017032711606 ][2017-04-08][z00353090] There are some unsafe function ,need to be replace with safe function */ + retVal = SPRINTF_S (tempbuf, PATA_STRLENT, "0x"); + if (-1 == retVal) + { + NSCOMM_LOGERR ("SPRINTF_S failed]ret=%d", ioffset); + return DMM_MBUF_RET_ERR; + } + ioffset = retVal; + for (Index = 0; Index < LCORE_MASK_MAX; Index++) + { + if (ioffset >= PATA_STRLENT) + { + NSCOMM_LOGERR ("SPRINTF_S tempbuf overflow]ioffset=%d", + ioffset); + return DMM_MBUF_RET_ERR; + } + retVal = + SPRINTF_S (&(tempbuf[ioffset]), PATA_STRLENT - ioffset, "%8u", + pinfo->ilcoremask[Index]); + if (-1 == retVal) + { + NSCOMM_LOGERR ("SPRINTF_S failed]ret=%d", ioffset); + return DMM_MBUF_RET_ERR; + } + ioffset = ioffset + retVal; + intmask |= pinfo->ilcoremask[Index]; + } + if (0 == intmask) + { + PARA2_SET (argv, tempargv, agindex, "-c", "0x1"); + } + else + { + PARA2_SET (argv, tempargv, agindex, "-c", tempbuf); + } + if (pinfo->ishare_mem_size > 0) + { + retVal = MEMSET_S (tempbuf, PATA_STRLENT, 0, PATA_NUM_MAX); + if (EOK != retVal) + { + NSCOMM_LOGERR ("MEMSET_S failed]ret=%d", retVal); + return DMM_MBUF_RET_ERR; + } + retVal = + SPRINTF_S (tempbuf, PATA_STRLENT, "%d", pinfo->ishare_mem_size); + if (-1 == retVal) + { + NSCOMM_LOGERR ("SPRINTF_S failed]ret=%d", retVal); + return DMM_MBUF_RET_ERR; + } + PARA2_SET (argv, tempargv, agindex, "-m", tempbuf); + } + + retVal = MEMSET_S (tempbuf, PATA_STRLENT, 0, PATA_NUM_MAX); + if (EOK != retVal) + { + NSCOMM_LOGERR ("MEMSET_S failed]ret=%d", retVal); + return DMM_MBUF_RET_ERR; + } + + switch (pinfo->ucproctype) + { + case DMM_PROC_T_PRIMARY: + retVal = SPRINTF_S (tempbuf, PATA_STRLENT, "--proc-type=primary"); + if (-1 == retVal) + { + NSCOMM_LOGERR ("SPRINTF_S failed]ret=%d", retVal); + return DMM_MBUF_RET_ERR; + } + break; + case DMM_PROC_T_SECONDARY: + retVal = SPRINTF_S (tempbuf, PATA_STRLENT, "--proc-type=secondary"); + if (-1 == retVal) + { + NSCOMM_LOGERR ("SPRINTF_S failed]ret=%d", retVal); + return DMM_MBUF_RET_ERR; + } + break; + case DMM_PROC_T_AUTO: + default: + retVal = SPRINTF_S (tempbuf, PATA_STRLENT, "--proc-type=auto"); + if (-1 == retVal) + { + NSCOMM_LOGERR ("SPRINTF_S failed]ret=%d", retVal); + return DMM_MBUF_RET_ERR; + } + break; + } + PARA1_SET (argv, tempargv, agindex, tempbuf); + + if (DMM_HUGTBL_DISABLE == pinfo->uchugeflag) + { + PARA1_SET (argv, tempargv, agindex, "--no-huge"); + } + } + if (common_mem_pal_init (agindex, argv) < 0) + { + COMMON_LOG_PRINT (LOG_ERR, "Cannot init pal\r\n"); + return DMM_MBUF_RET_ERR; + } + return DMM_MBUF_RET_OK; +} + +void * +nscomm_memzone_data_reserve_name (const char *name, size_t len, int socket_id) +{ + const struct common_mem_memzone *mz = NULL; + /* + rte_memzone_reserve must Call first, cause rte_memzone_reserve has a globe lock. + while proc race happen, who(calls A) got lock first will create memzone success. + others create same memzone proc will got lock after A, and rte_memzone_reserve return NULL; + so while rte_memzone_reserve return NULL we need do rte_memzone_lookup; + */ + mz = common_mem_memzone_reserve (name, len, socket_id, 0); + if (mz == NULL) + { + mz = common_mem_memzone_lookup (name); + } + + return mz ? (void *) ADDR_SHTOL (mz->addr_64) : NULL; +} + +void * +nscomm_memzone_data_lookup_name (const char *name) +{ + void *addr = NULL; + const struct common_mem_memzone *mz = NULL; + mz = common_mem_memzone_lookup (name); + if (mz == NULL) + { + return NULL; + } + addr = (void *) ADDR_SHTOL (mz->addr_64); + return addr; +} diff --git a/src/framework/lib_common_mem/common_func.c b/src/framework/lib_common_mem/common_func.c new file mode 100644 index 0000000..f68380f --- /dev/null +++ b/src/framework/lib_common_mem/common_func.c @@ -0,0 +1,205 @@ +/* +* +* 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 "common_mem_pal_memconfig.h" +#include "common_mem_mbuf.h" +#include "common_mem_common.h" +#include "nstack_log.h" +#include "common_pal_bitwide_adjust.h" + +#include "common_func.h" + +#include "nstack_securec.h" + +#define COMMON_PROCESS_MAPS "/proc/self/maps" + +int g_PrimSameFlg = 1; + +NSTACK_STATIC void **g_PrimAddr2LocalMap = NULL; +NSTACK_STATIC void *g_LocalBaseAddr = NULL; +NSTACK_STATIC void *g_LocalMaxAddr = NULL; +NSTACK_STATIC void *g_LocalCfgAddrBase = NULL; + +NSTACK_STATIC uint64_t *g_LocalAddr2PrimMap = NULL; +NSTACK_STATIC uint64_t g_PrimBaseAddr = 0; +NSTACK_STATIC uint64_t g_PrimMaxAddr = 0; +NSTACK_STATIC uint64_t g_PrimCfgAddrBase = 0; + +NSTACK_STATIC uint64_t g_LBitMask = 0; +NSTACK_STATIC int g_LBitMaskLen = 0; + +uint64_t +pal_laddr_to_shddr (void *LAddr) +{ + size_t l2pIdx; + + if (g_PrimSameFlg || LAddr == NULL) + { + return (uint64_t) LAddr; + } + + /*calculate the IDX */ + l2pIdx = (ALIGN_PTR (LAddr) - ALIGN_PTR (g_LocalBaseAddr)) >> g_LBitMaskLen; + + /*check the Hugepage Addr Rang */ + if (LAddr <= g_LocalMaxAddr && LAddr >= g_LocalBaseAddr + && g_LocalAddr2PrimMap[l2pIdx]) + { + return g_LocalAddr2PrimMap[l2pIdx] + (ALIGN_PTR (LAddr) & g_LBitMask); + } + + /*check the Cfg Mapping Addr Rang */ + if (LAddr >= g_LocalCfgAddrBase + && LAddr <= + (void *) ((char *) g_LocalCfgAddrBase + + sizeof (struct common_mem_mem_config))) + { + return g_PrimCfgAddrBase + ((char *) LAddr - + (char *) g_LocalCfgAddrBase); + } + + NSCOMM_LOGWAR + ("WARNING!!! Input invalid LAddr]LAddr=%p, g_LocalBaseAddr=%p, g_LocalMaxAddr=%p, g_LocalCfgAddrBase=%p, g_LocalCfgAddrMax=%p.", + LAddr, g_LocalBaseAddr, g_LocalMaxAddr, g_LocalCfgAddrBase, + (char *) g_LocalCfgAddrBase + sizeof (struct common_mem_mem_config)); + + return (uint64_t) LAddr; +} + +void * +pal_shddr_to_laddr (uint64_t PAddr) +{ + size_t p2lIdx; + + if (g_PrimSameFlg || PAddr == ALIGN_PTR (NULL)) + { + return (void *) PAddr; + } + + p2lIdx = (PAddr - g_PrimBaseAddr) >> g_LBitMaskLen; + /*check the Hugepage Addr Rang */ + if (PAddr <= g_PrimMaxAddr && PAddr >= g_PrimBaseAddr + && g_PrimAddr2LocalMap[p2lIdx]) + { + return (void *) ((uint64_t) g_PrimAddr2LocalMap[p2lIdx] + + (PAddr & g_LBitMask)); + } + + /*check the Cfg Mapping Addr Rang */ + if (PAddr >= g_PrimCfgAddrBase + && PAddr <= g_PrimCfgAddrBase + sizeof (struct common_mem_mem_config)) + { + return (void *) ((uint64_t) g_LocalCfgAddrBase + PAddr - + g_PrimCfgAddrBase); + } + + NSCOMM_LOGWAR + ("WARNING!!! Input invalid PAddr]PAddr=%lx, g_PrimBaseAddr=%lx, g_PrimMaxAddr=%lx, g_PrimCfgAddrBase=%lx, g_PrimCfgAddrMax=%lx.", + PAddr, g_PrimBaseAddr, g_PrimMaxAddr, g_PrimCfgAddrBase, + g_PrimCfgAddrBase + sizeof (struct common_mem_mem_config)); + + return (void *) PAddr; +} + +/*lint +e539 */ + +int +dmm_pal_addr_align () +{ + return g_PrimSameFlg; +} + +int32_t +dmm_pktmbuf_pool_iterator (struct common_mem_mempool * mp, uint32_t start, + uint32_t end, dmm_mbuf_item_fun fun, void *argv) +{ + if (NULL == mp || fun == NULL) + { + return 0; + } + + if (start >= mp->size || end <= start) + { + return 0; + } + + int32_t elm_size = mp->elt_size + mp->header_size + mp->trailer_size; + struct common_mem_mbuf *elm_mbuf = (struct common_mem_mbuf *) (mp->elt_va_start + start * elm_size + mp->header_size); /*lint !e647 */ + + uint32_t i; + uint32_t mbuf_end = COMMON_MEM_MIN (end, mp->size) - start; + for (i = 0; i < mbuf_end; i++) + { + (void) fun (elm_mbuf, argv); + elm_mbuf = (struct common_mem_mbuf *) ((char *) elm_mbuf + elm_size); + } + + return mbuf_end; +} + +void +dmm_addr_print (void) +{ + const struct common_mem_mem_config *mcfg = + common_mem_pal_get_configuration ()->mem_config; + int s; + FILE *fd; + char *ptembuf = NULL; + if (!mcfg) + { + NSCOMM_LOGERR ("mcfg is null"); + return; + } + /*printf base address */ + NSCOMM_LOGINF ("********master baseaddr begin***************"); + for (s = 0; s < COMMON_MEM_MAX_MEMSEG; ++s) + { + if ((mcfg->memseg[s].len > 0) && (mcfg->memseg[s].addr != 0)) + { + NSCOMM_LOGINF ("addr:%p, len:%u", mcfg->memseg[s].addr, + mcfg->memseg[s].len); + } + } + NSCOMM_LOGINF ("********master baseaddr end***************"); + + fd = fopen (COMMON_PROCESS_MAPS, "r"); + if (!fd) + { + NSCOMM_LOGERR ("/proc/self/maps open fail, erro:%d", errno); + return; + } + + ptembuf = (char *) malloc (BUFSIZ); + if (!ptembuf) + { + NSCOMM_LOGERR ("malloc buff failed]buff_len=%d", BUFSIZ); + fclose (fd); + return; + } + if (EOK != MEMSET_S (ptembuf, BUFSIZ, 0, BUFSIZ)) + { + NSCOMM_LOGERR ("MEMSET_S failed] buff=%p", ptembuf); + } + NSCOMM_LOGINF ("********self process addr space begin***************"); + while (fgets (ptembuf, BUFSIZ, fd) != NULL) + { + NSCOMM_LOGERR ("%s", ptembuf); + } + NSCOMM_LOGINF ("********self process addr space end*****************"); + fclose (fd); + free (ptembuf); + return; +} |