From 2a42ad20b9730706ad371ae3787d4597c4e42276 Mon Sep 17 00:00:00 2001 From: sharath reddy Date: Tue, 4 Jun 2019 11:53:49 +0530 Subject: Feature: 19.04 part-2 Change-Id: I0b52a6bb67c25c7955d58e29eb81a3cc9efea9e9 Signed-off-by: sharath reddy --- .../lwip_stack/src/mem/lib_common_mem/common_api.c | 163 +++++++++++ .../lwip_stack/src/mem/lib_common_mem/common_buf.c | 299 +++++++++++++++++++++ .../src/mem/lib_common_mem/common_func.c | 211 +++++++++++++++ 3 files changed, 673 insertions(+) create mode 100644 stacks/lwip_stack/src/mem/lib_common_mem/common_api.c create mode 100644 stacks/lwip_stack/src/mem/lib_common_mem/common_buf.c create mode 100644 stacks/lwip_stack/src/mem/lib_common_mem/common_func.c (limited to 'stacks/lwip_stack/src/mem/lib_common_mem') 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 +#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 +#include +#include +#include +#include +#include +#include +#include +#include + +#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); +} -- cgit 1.2.3-korg