summaryrefslogtreecommitdiffstats
path: root/stacks/lwip_stack/src/mem/lib_common_mem
diff options
context:
space:
mode:
Diffstat (limited to 'stacks/lwip_stack/src/mem/lib_common_mem')
-rw-r--r--stacks/lwip_stack/src/mem/lib_common_mem/common_api.c163
-rw-r--r--stacks/lwip_stack/src/mem/lib_common_mem/common_buf.c299
-rw-r--r--stacks/lwip_stack/src/mem/lib_common_mem/common_func.c211
3 files changed, 673 insertions, 0 deletions
diff --git a/stacks/lwip_stack/src/mem/lib_common_mem/common_api.c b/stacks/lwip_stack/src/mem/lib_common_mem/common_api.c
new file mode 100644
index 0000000..453f33f
--- /dev/null
+++ b/stacks/lwip_stack/src/mem/lib_common_mem/common_api.c
@@ -0,0 +1,163 @@
+/*
+*
+* 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 "nstack_log.h"
+#include "nstack_securec.h"
+#include "common_func.h"
+#include "pid_common.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. */
+u32_t sys_now(void)
+{
+ struct timespec now;
+
+ if (unlikely(0 != clock_gettime(CLOCK_MONOTONIC, &now)))
+ {
+ NSRTP_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)
+ {
+ NSRTP_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;
+}
+
+/*****************************************************************************
+* 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/stacks/lwip_stack/src/mem/lib_common_mem/common_buf.c b/stacks/lwip_stack/src/mem/lib_common_mem/common_buf.c
new file mode 100644
index 0000000..98983d5
--- /dev/null
+++ b/stacks/lwip_stack/src/mem/lib_common_mem/common_buf.c
@@ -0,0 +1,299 @@
+/*
+*
+* 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_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(level, fmt, args...) \
+ if (level <= log_level) NSRTP_LOGERR("===>[COMMON]"fmt, ##args); \
+
+#define COMMON_PANIC(fmt) \
+ NSRTP_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)\
+ {\
+ NSRTP_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)\
+ {\
+ NSRTP_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)\
+ {\
+ NSRTP_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_level = LOG_INFO;
+
+int
+nscomm_pal_module_init(nsfw_mem_para * para,
+ common_mem_pal_module_info * pinfo, u8 app_mode)
+{
+ 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;
+ char name[10] = { '\0' };
+
+ if (para == NULL)
+ {
+ NSRTP_LOGERR("para is null");
+ return DMM_MBUF_RET_ERR;
+ }
+
+ retVal = memset_s(tempargv, sizeof(tempargv), '\0', sizeof(tempargv));
+ if (EOK != retVal)
+ {
+ NSRTP_LOGERR("MEMSET_S failed]ret=%d", retVal);
+ return DMM_MBUF_RET_ERR;
+ }
+ retVal = memset_s(argv, sizeof(argv), 0, sizeof(argv));
+ if (EOK != retVal)
+ {
+ NSRTP_LOGERR("MEMSET_S failed]ret=%d", retVal);
+ return DMM_MBUF_RET_ERR;
+ }
+ if (NSFW_PROC_MAIN == para->enflag)
+ {
+ if (para->iargsnum != 0)
+ {
+ if (common_mem_pal_init(para->iargsnum, para->pargs) < 0)
+ {
+ COMMON_LOG_PRINT(LOG_ERR, "Cannot init pal\r\n");
+ return DMM_MBUF_RET_ERR;
+ }
+ else
+ {
+ return DMM_MBUF_RET_OK;
+ }
+ }
+
+ PARA1_SET(argv, tempargv, agindex, "nStackMain");
+ PARA2_SET(argv, tempargv, agindex, "-c", "0x1");
+ PARA2_SET(argv, tempargv, agindex, "-n", "4");
+ PARA1_SET(argv, tempargv, agindex, "--huge-dir=/mnt/nstackhuge");
+ PARA1_SET(argv, tempargv, agindex, "--proc-type=primary");
+
+ if (app_mode == 1)
+ {
+ sprintf(name, "dmm_app_%ld", (long) getpid());
+ PARA2_SET(argv, tempargv, agindex, "--file-prefix", name);
+ PARA1_SET(argv, tempargv, agindex, "--no-pci");
+
+ // TODO: the size of the memory should not be fixed
+ PARA2_SET(argv, tempargv, agindex, "-m", "32");
+ }
+ else
+ {
+ // TODO: replay the name 'nStackMain'
+ /* snprintf(name, 10, "dmm_main_%ld", (long) getpid()); */
+ PARA2_SET(argv, tempargv, agindex, "--file-prefix", "nStackMain");
+ PARA2_SET(argv, tempargv, agindex, "-m", "2048");
+ }
+
+ }
+ else
+ {
+ PARA1_SET(argv, tempargv, agindex, "nStackMain");
+ PARA2_SET(argv, tempargv, agindex, "--file-prefix", "nStackMain");
+
+ retVal = sprintf_s(tempbuf, PATA_STRLENT, "0x");
+ if (-1 == retVal)
+ {
+ NSRTP_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)
+ {
+ NSRTP_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)
+ {
+ NSRTP_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)
+ {
+ NSRTP_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)
+ {
+ NSRTP_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)
+ {
+ NSRTP_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)
+ {
+ NSRTP_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)
+ {
+ NSRTP_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)
+ {
+ NSRTP_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/stacks/lwip_stack/src/mem/lib_common_mem/common_func.c b/stacks/lwip_stack/src/mem/lib_common_mem/common_func.c
new file mode 100644
index 0000000..6dd3d13
--- /dev/null
+++ b/stacks/lwip_stack/src/mem/lib_common_mem/common_func.c
@@ -0,0 +1,211 @@
+/*
+*
+* 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);
+ }
+
+ NSRTP_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);
+ }
+
+ NSRTP_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 *) (STAILQ_FIRST(&mp->mem_list)->addr + 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)
+ {
+ NSRTP_LOGERR("mcfg is null");
+ return;
+ }
+ /*printf base address */
+ NSRTP_LOGINF("********master baseaddr begin***************");
+ for (s = 0; s < COMMON_MEM_MAX_MEMSEG; ++s)
+ {
+ if ((mcfg->memseg[s].len > 0) && (mcfg->memseg[s].addr != 0))
+ {
+ NSRTP_LOGINF("addr:%p, len:%u", mcfg->memseg[s].addr,
+ mcfg->memseg[s].len);
+ }
+ }
+ NSRTP_LOGINF("********master baseaddr end***************");
+
+ fd = fopen(COMMON_PROCESS_MAPS, "r");
+ if (!fd)
+ {
+ NSRTP_LOGERR("/proc/self/maps open fail, erro:%d", errno);
+ return;
+ }
+
+ ptembuf = (char *) malloc(BUFSIZ);
+ if (!ptembuf)
+ {
+ NSRTP_LOGERR("malloc buff failed]buff_len=%d", BUFSIZ);
+ fclose(fd);
+ return;
+ }
+ if (EOK != memset_s(ptembuf, BUFSIZ, 0, BUFSIZ))
+ {
+ NSRTP_LOGERR("MEMSET_S failed] buff=%p", ptembuf);
+ }
+ NSRTP_LOGINF("********self process addr space begin***************");
+ while (fgets(ptembuf, BUFSIZ, fd) != NULL)
+ {
+ NSRTP_LOGERR("%s", ptembuf);
+ }
+ NSRTP_LOGINF("********self process addr space end*****************");
+ fclose(fd);
+ free(ptembuf);
+ return;
+}
+
+void *shmem_shddr_to_laddr(void *addr)
+{
+ return ADDR_SHTOL(addr);
+}
+
+uint64_t shmem_laddr_to_shddr(void *addr)
+{
+ return ADDR_LTOSH(addr);
+}