aboutsummaryrefslogtreecommitdiffstats
path: root/src/framework/lib_common_mem
diff options
context:
space:
mode:
Diffstat (limited to 'src/framework/lib_common_mem')
-rw-r--r--src/framework/lib_common_mem/common_api.c325
-rw-r--r--src/framework/lib_common_mem/common_buf.c260
-rw-r--r--src/framework/lib_common_mem/common_func.c205
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;
+}