packages/etmem
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

etmem: sync source repo submission

Browse Source 
Sync the features and bug fixed in the etmem
source repository.

Signed-off-by: liubo <liubo254@huawei.com>
(cherry picked from commit 07dd6a411bce9ed3d9f617a6f01ae076e24a3adf)
This commit is contained in:
liubo 2022-08-01 10:57:24 +08:00 committed by openeuler-sync-bot
parent 06a2b843ca
commit fe6d2a0135
34 changed files with 15271 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
0052-etmem-correct-example-config-file.patch Normal file
View File

@ -0,0 +1,38 @@
From 560e15aea0edc9bf53f33e739b6d430f4fe16150 Mon Sep 17 00:00:00 2001
From: Kemeng Shi <shikemeng@huawei.com>
Date: Tue, 19 Oct 2021 10:36:01 +0800
Subject: [PATCH 01/33] etmem: correct example config file
corret value config in cslide task
corret node_pair config in cslide engine
Signed-off-by: Kemeng Shi <shikemeng@huawei.com>
---
etmem/conf/example_conf.yaml | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/etmem/conf/example_conf.yaml b/etmem/conf/example_conf.yaml
index de612f6..61ee68c 100644
--- a/etmem/conf/example_conf.yaml
+++ b/etmem/conf/example_conf.yaml
@@ -22,7 +22,7 @@ max_threads=1
[engine]
name=cslide
project=test
-node_pair=2,0;3,1
+node_pair=0,2;1,3
hot_threshold=1
node_mig_quota=1024
node_hot_reserve=1024
@@ -32,7 +32,7 @@ project=test
engine=cslide
name=background_cslide
type=pid
-name=23456
+value=23456
vm_flags=ht
anon_only=no
ign_host=no
--
1.8.3.1

167
0053-etmem-split-example_conf.yaml.patch Normal file
View File

@ -0,0 +1,167 @@
From 0b40944b0a57393ccedb19b18f5c8307cfd42ffe Mon Sep 17 00:00:00 2001
From: Kemeng Shi <shikemeng@huawei.com>
Date: Tue, 19 Oct 2021 10:43:09 +0800
Subject: [PATCH 02/33] etmem: split example_conf.yaml
User can't use example_conf.yaml directly as it contains diffrent
engine configs. Split it into three single engine config and user
can use it directly
Signed-off-by: Kemeng Shi <shikemeng@huawei.com>
---
etmem/conf/cslide_conf.yaml | 24 ++++++++++++++++++
etmem/conf/example_conf.yaml | 56 -----------------------------------------
etmem/conf/slide_conf.yaml | 18 +++++++++++++
etmem/conf/thirdparty_conf.yaml | 21 ++++++++++++++++
4 files changed, 63 insertions(+), 56 deletions(-)
create mode 100644 etmem/conf/cslide_conf.yaml
delete mode 100644 etmem/conf/example_conf.yaml
create mode 100644 etmem/conf/slide_conf.yaml
create mode 100644 etmem/conf/thirdparty_conf.yaml
diff --git a/etmem/conf/cslide_conf.yaml b/etmem/conf/cslide_conf.yaml
new file mode 100644
index 0000000..6b6ecc3
--- /dev/null
+++ b/etmem/conf/cslide_conf.yaml
@@ -0,0 +1,24 @@
+[project]
+name=test
+loop=1
+interval=1
+sleep=1
+
+#cslide
+[engine]
+name=cslide
+project=test
+node_pair=0,2;1,3
+hot_threshold=1
+node_mig_quota=1024
+node_hot_reserve=1024
+
+[task]
+project=test
+engine=cslide
+name=background_cslide
+type=pid
+value=23456
+vm_flags=ht
+anon_only=no
+ign_host=no
diff --git a/etmem/conf/example_conf.yaml b/etmem/conf/example_conf.yaml
deleted file mode 100644
index 61ee68c..0000000
--- a/etmem/conf/example_conf.yaml
+++ /dev/null
@@ -1,56 +0,0 @@
-[project]
-name=test
-loop=1
-interval=1
-sleep=1
-
-#slide
-[engine]
-name=slide
-project=test
-
-[task]
-project=test
-engine=slide
-name=background_slide
-type=name
-value=mysql
-T=1
-max_threads=1
-
-#cslide
-[engine]
-name=cslide
-project=test
-node_pair=0,2;1,3
-hot_threshold=1
-node_mig_quota=1024
-node_hot_reserve=1024
-
-[task]
-project=test
-engine=cslide
-name=background_cslide
-type=pid
-value=23456
-vm_flags=ht
-anon_only=no
-ign_host=no
-
-#thirdparty
-[engine]
-name=thirdparty
-project=test
-eng_name=my_engine
-libname=/usr/lib/etmem_fetch/my_engine.so
-ops_name=my_engine_ops
-engine_private_key=engine_private_value
-
-[task]
-project=test
-engine=my_engine
-name=backgroud_third
-type=pid
-value=12345
-task_private_key=task_private_value
-
diff --git a/etmem/conf/slide_conf.yaml b/etmem/conf/slide_conf.yaml
new file mode 100644
index 0000000..b99ab50
--- /dev/null
+++ b/etmem/conf/slide_conf.yaml
@@ -0,0 +1,18 @@
+[project]
+name=test
+loop=1
+interval=1
+sleep=1
+
+[engine]
+name=slide
+project=test
+
+[task]
+project=test
+engine=slide
+name=background_slide
+type=name
+value=mysql
+T=1
+max_threads=1
diff --git a/etmem/conf/thirdparty_conf.yaml b/etmem/conf/thirdparty_conf.yaml
new file mode 100644
index 0000000..1e1e9ac
--- /dev/null
+++ b/etmem/conf/thirdparty_conf.yaml
@@ -0,0 +1,21 @@
+[project]
+name=test
+loop=1
+interval=1
+sleep=1
+
+[engine]
+name=thirdparty
+project=test
+eng_name=my_engine
+libname=/usr/lib/etmem_fetch/my_engine.so
+ops_name=my_engine_ops
+engine_private_key=engine_private_value
+
+[task]
+project=test
+engine=my_engine
+name=backgroud_third
+type=pid
+value=12345
+task_private_key=task_private_value
--
1.8.3.1

146
0054-add-License-in-memRouter.patch Normal file
View File

@ -0,0 +1,146 @@
From 4a8a5272e74994a694b88ab516a5331deea25bd2 Mon Sep 17 00:00:00 2001
From: volcanodragon <linfeilong@huawei.com>
Date: Tue, 9 Nov 2021 15:40:17 +0800
Subject: [PATCH 03/33] add License in memRouter
---
memRouter/License/LICENSE | 127 ++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 127 insertions(+)
create mode 100644 memRouter/License/LICENSE
diff --git a/memRouter/License/LICENSE b/memRouter/License/LICENSE
new file mode 100644
index 0000000..0db93af
--- /dev/null
+++ b/memRouter/License/LICENSE
@@ -0,0 +1,127 @@
+木兰宽松许可证, 第2版
+
+ 木兰宽松许可证， 第2版
+ 2020年1月 http://license.coscl.org.cn/MulanPSL2
+
+
+ 您对“软件”的复制、使用、修改及分发受木兰宽松许可证，第2版（“本许可证”）的如下条款的约束：
+
+ 0. 定义
+
+ “软件”是指由“贡献”构成的许可在“本许可证”下的程序和相关文档的集合。
+
+ “贡献”是指由任一“贡献者”许可在“本许可证”下的受版权法保护的作品。
+
+ “贡献者”是指将受版权法保护的作品许可在“本许可证”下的自然人或“法人实体”。
+
+ “法人实体”是指提交贡献的机构及其“关联实体”。
+
+ “关联实体”是指，对“本许可证”下的行为方而言，控制、受控制或与其共同受控制的机构，此处的控制是指有受控方或共同受控方至少50%直接或间接的投票权、资金或其他有价证券。
+
+ 1. 授予版权许可
+
+ 每个“贡献者”根据“本许可证”授予您永久性的、全球性的、免费的、非独占的、不可撤销的版权许可，您可以复制、使用、修改、分发其“贡献”，不论修改与否。
+
+ 2. 授予专利许可
+
+ 每个“贡献者”根据“本许可证”授予您永久性的、全球性的、免费的、非独占的、不可撤销的（根据本条规定撤销除外）专利许可，供您制造、委托制造、使用、许诺销售、销售、进口其“贡献”或以其他方式转移其“贡献”。前述专利许可仅限于“贡献者”现在或将来拥有或控制的其“贡献”本身或其“贡献”与许可“贡献”时的“软件”结合而将必然会侵犯的专利权利要求，不包括对“贡献”的修改或包含“贡献”的其他结合。如果您或您的“关联实体”直接或间接地，就“软件”或其中的“贡献”对任何人发起专利侵权诉讼（包括反诉或交叉诉讼）或其他专利维权行动，指控其侵犯专利权，则“本许可证”授予您对“软件”的专利许可自您提起诉讼或发起维权行动之日终止。
+
+ 3. 无商标许可
+
+ “本许可证”不提供对“贡献者”的商品名称、商标、服务标志或产品名称的商标许可，但您为满足第4条规定的声明义务而必须使用除外。
+
+ 4. 分发限制
+
+ 您可以在任何媒介中将“软件”以源程序形式或可执行形式重新分发，不论修改与否，但您必须向接收者提供“本许可证”的副本，并保留“软件”中的版权、商标、专利及免责声明。
+
+ 5. 免责声明与责任限制
+
+ “软件”及其中的“贡献”在提供时不带任何明示或默示的担保。在任何情况下，“贡献者”或版权所有者不对任何人因使用“软件”或其中的“贡献”而引发的任何直接或间接损失承担责任，不论因何种原因导致或者基于何种法律理论，即使其曾被建议有此种损失的可能性。
+
+ 6. 语言
+ “本许可证”以中英文双语表述，中英文版本具有同等法律效力。如果中英文版本存在任何冲突不一致，以中文版为准。
+
+ 条款结束
+
+ 如何将木兰宽松许可证，第2版，应用到您的软件
+
+ 如果您希望将木兰宽松许可证，第2版，应用到您的新软件，为了方便接收者查阅，建议您完成如下三步：
+
+ 1， 请您补充如下声明中的空白，包括软件名、软件的首次发表年份以及您作为版权人的名字；
+
+ 2， 请您在软件包的一级目录下创建以“LICENSE”为名的文件，将整个许可证文本放入该文件中；
+
+ 3， 请将如下声明文本放入每个源文件的头部注释中。
+
+ Copyright (c) [Year] [name of copyright holder]
+ [Software Name] is licensed under Mulan PSL v2.
+ You can use this software according to the terms and conditions of the Mulan PSL v2.
+ You may obtain a copy of Mulan PSL v2 at:
+ http://license.coscl.org.cn/MulanPSL2
+ THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ See the Mulan PSL v2 for more details.
+
+
+ Mulan Permissive Software License，Version 2
+
+ Mulan Permissive Software License，Version 2 (Mulan PSL v2)
+ January 2020 http://license.coscl.org.cn/MulanPSL2
+
+ Your reproduction, use, modification and distribution of the Software shall be subject to Mulan PSL v2 (this License) with the following terms and conditions:
+
+ 0. Definition
+
+ Software means the program and related documents which are licensed under this License and comprise all Contribution(s).
+
+ Contribution means the copyrightable work licensed by a particular Contributor under this License.
+
+ Contributor means the Individual or Legal Entity who licenses its copyrightable work under this License.
+
+ Legal Entity means the entity making a Contribution and all its Affiliates.
+
+ Affiliates means entities that control, are controlled by, or are under common control with the acting entity under this License, ‘control’ means direct or indirect ownership of at least fifty percent (50%) of the voting power, capital or other securities of controlled or commonly controlled entity.
+
+ 1. Grant of Copyright License
+
+ Subject to the terms and conditions of this License, each Contributor hereby grants to you a perpetual, worldwide, royalty-free, non-exclusive, irrevocable copyright license to reproduce, use, modify, or distribute its Contribution, with modification or not.
+
+ 2. Grant of Patent License
+
+ Subject to the terms and conditions of this License, each Contributor hereby grants to you a perpetual, worldwide, royalty-free, non-exclusive, irrevocable (except for revocation under this Section) patent license to make, have made, use, offer for sale, sell, import or otherwise transfer its Contribution, where such patent license is only limited to the patent claims owned or controlled by such Contributor now or in future which will be necessarily infringed by its Contribution alone, or by combination of the Contribution with the Software to which the Contribution was contributed. The patent license shall not apply to any modification of the Contribution, and any other combination which includes the Contribution. If you or your Affiliates directly or indirectly institute patent litigation (including a cross claim or counterclaim in a litigation) or other patent enforcement activities against any individual or entity by alleging that the Software or any Contribution in it infringes patents, then any patent license granted to you under this License for the Software shall terminate as of the date such litigation or activity is filed or taken.
+
+ 3. No Trademark License
+
+ No trademark license is granted to use the trade names, trademarks, service marks, or product names of Contributor, except as required to fulfill notice requirements in Section 4.
+
+ 4. Distribution Restriction
+
+ You may distribute the Software in any medium with or without modification, whether in source or executable forms, provided that you provide recipients with a copy of this License and retain copyright, patent, trademark and disclaimer statements in the Software.
+
+ 5. Disclaimer of Warranty and Limitation of Liability
+
+ THE SOFTWARE AND CONTRIBUTION IN IT ARE PROVIDED WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED. IN NO EVENT SHALL ANY CONTRIBUTOR OR COPYRIGHT HOLDER BE LIABLE TO YOU FOR ANY DAMAGES, INCLUDING, BUT NOT LIMITED TO ANY DIRECT, OR INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING FROM YOUR USE OR INABILITY TO USE THE SOFTWARE OR THE CONTRIBUTION IN IT, NO MATTER HOW IT’S CAUSED OR BASED ON WHICH LEGAL THEORY, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+ 6. Language
+
+ THIS LICENSE IS WRITTEN IN BOTH CHINESE AND ENGLISH, AND THE CHINESE VERSION AND ENGLISH VERSION SHALL HAVE THE SAME LEGAL EFFECT. IN THE CASE OF DIVERGENCE BETWEEN THE CHINESE AND ENGLISH VERSIONS, THE CHINESE VERSION SHALL PREVAIL.
+
+ END OF THE TERMS AND CONDITIONS
+
+ How to Apply the Mulan Permissive Software License，Version 2 (Mulan PSL v2) to Your Software
+
+ To apply the Mulan PSL v2 to your work, for easy identification by recipients, you are suggested to complete following three steps:
+
+ i Fill in the blanks in following statement, including insert your software name, the year of the first publication of your software, and your name identified as the copyright owner;
+
+ ii Create a file named “LICENSE” which contains the whole context of this License in the first directory of your software package;
+
+ iii Attach the statement to the appropriate annotated syntax at the beginning of each source file.
+
+
+ Copyright (c) [Year] [name of copyright holder]
+ [Software Name] is licensed under Mulan PSL v2.
+ You can use this software according to the terms and conditions of the Mulan PSL v2.
+ You may obtain a copy of Mulan PSL v2 at:
+ http://license.coscl.org.cn/MulanPSL2
+ THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ See the Mulan PSL v2 for more details.
--
1.8.3.1

698
0055-add-code-of-testcase-for-etmem-common-function.patch Normal file
View File

@ -0,0 +1,698 @@
From e36c5a68a748080a473988c7530786f3f7ac90d3 Mon Sep 17 00:00:00 2001
From: louhongxiang <louhongxiang@huawei.com>
Date: Mon, 22 Nov 2021 17:51:33 +0800
Subject: [PATCH 04/33] add code of testcase for etmem common function.
---
etmem/test/CMakeLists.txt | 198 ++++++++++++++++++++++++
etmem/test/common/test_common.c | 327 ++++++++++++++++++++++++++++++++++++++++
etmem/test/common/test_common.h | 138 +++++++++++++++++
3 files changed, 663 insertions(+)
create mode 100644 etmem/test/CMakeLists.txt
create mode 100644 etmem/test/common/test_common.c
create mode 100644 etmem/test/common/test_common.h
diff --git a/etmem/test/CMakeLists.txt b/etmem/test/CMakeLists.txt
new file mode 100644
index 0000000..5bf3477
--- /dev/null
+++ b/etmem/test/CMakeLists.txt
@@ -0,0 +1,198 @@
+# /******************************************************************************
+# * Copyright (c) Huawei Technologies Co., Ltd. 2019-2021. All rights reserved.
+# * etmem is licensed under the Mulan PSL v2.
+# * You can use this software according to the terms and conditions of the Mulan PSL v2.
+# * You may obtain a copy of Mulan PSL v2 at:
+# * http://license.coscl.org.cn/MulanPSL2
+# * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+# * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+# * PURPOSE.
+# * See the Mulan PSL v2 for more details.
+# * Author: louhongxiang
+# * Create: 2021-11-19
+# * Description: CMakefileList for etmem to compile
+# ******************************************************************************/
+
+cmake_minimum_required (VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
+project(etmem)
+
+EXECUTE_PROCESS( COMMAND uname -m COMMAND tr -d '\n' OUTPUT_VARIABLE ARCHITECTURE )
+message( STATUS "Architecture: ${ARCHITECTURE}" )
+
+set(ETMEMD_SRC_DIR ${PROJECT_SOURCE_DIR}/../src/etmemd_src)
+set(ETMEM_SRC_DIR ${PROJECT_SOURCE_DIR}/../src/etmem_src)
+set(TEST_COMMON_DIR ${PROJECT_SOURCE_DIR}/common)
+set(BUILD_DIR ${PROJECT_SOURCE_DIR}/build)
+
+set(ETMEMD_SRC
+ ${ETMEMD_SRC_DIR}/etmemd.c
+ ${ETMEMD_SRC_DIR}/etmemd_file.c
+ ${ETMEMD_SRC_DIR}/etmemd_common.c
+ ${ETMEMD_SRC_DIR}/etmemd_rpc.c
+ ${ETMEMD_SRC_DIR}/etmemd_log.c
+ ${ETMEMD_SRC_DIR}/etmemd_project.c
+ ${ETMEMD_SRC_DIR}/etmemd_engine.c
+ ${ETMEMD_SRC_DIR}/etmemd_memdcd.c
+ ${ETMEMD_SRC_DIR}/etmemd_slide.c
+ ${ETMEMD_SRC_DIR}/etmemd_cslide.c
+ ${ETMEMD_SRC_DIR}/etmemd_thirdparty.c
+ ${ETMEMD_SRC_DIR}/etmemd_task.c
+ ${ETMEMD_SRC_DIR}/etmemd_scan.c
+ ${ETMEMD_SRC_DIR}/etmemd_threadpool.c
+ ${ETMEMD_SRC_DIR}/etmemd_threadtimer.c
+ ${ETMEMD_SRC_DIR}/etmemd_pool_adapter.c
+ ${ETMEMD_SRC_DIR}/etmemd_migrate.c)
+
+set(ETMEM_SRC
+ ${ETMEM_SRC_DIR}/etmem.c
+ ${ETMEM_SRC_DIR}/etmem_project.c
+ ${ETMEM_SRC_DIR}/etmem_obj.c
+ ${ETMEM_SRC_DIR}/etmem_engine.c
+ ${ETMEM_SRC_DIR}/etmem_rpc.c
+ ${ETMEM_SRC_DIR}/etmem_common.c)
+
+set(ETMEMD_CSLIDE_DEP
+ ${ETMEMD_SRC_DIR}/etmemd.c
+ ${ETMEMD_SRC_DIR}/etmemd_file.c
+ ${ETMEMD_SRC_DIR}/etmemd_common.c
+ ${ETMEMD_SRC_DIR}/etmemd_rpc.c
+ ${ETMEMD_SRC_DIR}/etmemd_log.c
+ ${ETMEMD_SRC_DIR}/etmemd_project.c
+ ${ETMEMD_SRC_DIR}/etmemd_engine.c
+ ${ETMEMD_SRC_DIR}/etmemd_slide.c
+ ${ETMEMD_SRC_DIR}/etmemd_thirdparty.c
+ ${ETMEMD_SRC_DIR}/etmemd_task.c
+ ${ETMEMD_SRC_DIR}/etmemd_scan.c
+ ${ETMEMD_SRC_DIR}/etmemd_threadpool.c
+ ${ETMEMD_SRC_DIR}/etmemd_threadtimer.c
+ ${ETMEMD_SRC_DIR}/etmemd_pool_adapter.c
+ ${ETMEMD_SRC_DIR}/etmemd_migrate.c)
+
+set(TEST_COMMON_SRC
+ ${TEST_COMMON_DIR}/test_common.c)
+
+add_library(
+etmemd_shared
+SHARED
+${ETMEMD_SRC})
+
+add_library(
+etmem_shared
+SHARED
+${ETMEM_SRC})
+
+add_library(
+test_common
+SHARED
+${TEST_COMMON_SRC})
+
+add_library(
+cslide_dep
+SHARED
+${ETMEMD_CSLIDE_DEP})
+
+add_executable(etmemd
+ ${ETMEMD_SRC})
+
+add_executable(etmem
+ ${ETMEM_SRC})
+
+set(EXECUTABLE_OUTPUT_PATH ${BUILD_DIR}/bin)
+
+set(LIBRARY_OUTPUT_PATH ${BUILD_DIR}/lib)
+
+include(FindPkgConfig)
+pkg_search_module(GLIB2 REQUIRED glib-2.0)
+
+target_include_directories(etmemd PRIVATE
+ ${PROJECT_SOURCE_DIR}/../inc/etmemd_inc
+ ${GLIB2_INCLUDE_DIRS})
+
+target_include_directories(etmemd_shared PRIVATE
+ ${PROJECT_SOURCE_DIR}/../inc/etmemd_inc
+ ${GLIB2_INCLUDE_DIRS})
+
+target_include_directories(etmem PRIVATE
+ ${PROJECT_SOURCE_DIR}/../inc/etmem_inc)
+
+target_include_directories(etmem_shared PRIVATE
+ ${PROJECT_SOURCE_DIR}/../inc/etmem_inc)
+
+target_include_directories(test_common PRIVATE
+ ${PROJECT_SOURCE_DIR}/../inc/etmemd_inc
+ ${PROJECT_SOURCE_DIR}/COMMON
+ ${GLIB2_INCLUDE_DIRS})
+
+target_include_directories(cslide_dep PRIVATE
+ ${PROJECT_SOURCE_DIR}/../inc/etmemd_inc
+ ${GLIB2_INCLUDE_DIRS})
+
+if(COVERAGE_ENABLE)
+ message(STATUS "Enable coverage compile option")
+ SET(COVERAGE_OPTION "${COVERAGE_OPTION} -fprofile-arcs -ftest-coverage")
+endif(COVERAGE_ENABLE)
+
+if(ASAN_ENABLE)
+ message(STATUS "Enable asan compile option")
+ SET(ASAN_OPTIONS "${ASAN_OPTION} -fsanitize=address -fsanitize-recover=address")
+endif(ASAN_ENABLE)
+
+IF(CMAKE_BUILD_TYPE STREQUAL Debug)
+ SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${COVERAGE_OPTION} ${ASAN_OPTIONS}")
+ SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${COVERAGE_OPTION} ${ASAN_OPTIONS}")
+ENDIF()
+
+# set common compile options
+set(COMMON_COMPILE_OPT -fsigned-char -fno-omit-frame-pointer -Wall -Wextra -Wno-unused-parameter -Wno-missing-field-initializers -Wmissing-declarations -fno-strict-aliasing -Werror -Wformat -Wformat-security -D_GNU_SOURCE -fPIE -pie -fPIC -fstack-protector-strong -fno-common -DNDEBUG -O2 -D_FORTIFY_SOURCE=2 -Wall -Werror -Wl,-z,relro,-z,now,-z,noexecstack -Wtrampolines -pthread -Wno-pointer-sign -Wstrict-prototypes -Wold-style-definition -std=gnu99)
+
+if (CONFIG_DEBUG STREQUAL "y")
+ SET(COMMON_COMPILE_OPT ${COMMON_COMPILE_OPT} -g)
+endif()
+
+if( ${ARCHITECTURE} STREQUAL "aarch64")
+ SET(COMMON_COMPILE_OPT ${COMMON_COMPILE_OPT} -march=armv8-a)
+else()
+ SET(COMMON_COMPILE_OPT ${COMMON_COMPILE_OPT} -march=core-avx-i -m64)
+endif()
+
+# set common share library compile options
+set(SHARE_COMPILE_OPT -ldl -rdynamic)
+
+# set common link options
+set(COMMON_LINK_OPT "-fPIE -pie -fPIC -Wl,-z,relro,-z,now,-z,noexecstack -Wtrampolines")
+set(COMMON_LINK_LIB pthread dl rt boundscheck)
+set(SERVER_LINK_LIB numa ${GLIB2_LIBRARIES})
+
+# target etmemd
+target_compile_options(etmemd PRIVATE ${COMMON_COMPILE_OPT})
+set_target_properties(etmemd PROPERTIES LINK_FLAGS ${COMMON_LINK_OPT})
+target_link_libraries(etmemd PRIVATE ${COMMON_LINK_LIB} ${SERVER_LINK_LIB})
+
+# target etmem
+target_compile_options(etmem PRIVATE ${COMMON_COMPILE_OPT})
+set_target_properties(etmem PROPERTIES LINK_FLAGS ${COMMON_LINK_OPT})
+target_link_libraries(etmem PRIVATE ${COMMON_LINK_LIB} ${SERVER_LINK_LIB})
+
+# target etmemd share
+target_compile_options(etmemd_shared PRIVATE ${COMMON_COMPILE_OPT} ${SHARE_COMPILE_OPT})
+set_target_properties(etmemd_shared PROPERTIES LINK_FLAGS ${COMMON_LINK_OPT})
+target_link_libraries(etmemd_shared PRIVATE ${COMMON_LINK_LIB} ${SERVER_LINK_LIB})
+SET_TARGET_PROPERTIES(etmemd_shared PROPERTIES OUTPUT_NAME "etmemd")
+
+# target etmem share
+target_compile_options(etmem_shared PRIVATE ${COMMON_COMPILE_OPT} ${SHARE_COMPILE_OPT})
+set_target_properties(etmem_shared PROPERTIES LINK_FLAGS ${COMMON_LINK_OPT})
+target_link_libraries(etmem_shared PRIVATE ${COMMON_LINK_LIB})
+SET_TARGET_PROPERTIES(etmem_shared PROPERTIES OUTPUT_NAME "etmem")
+
+# target test etmemd share
+target_compile_options(test_common PRIVATE ${COMMON_COMPILE_OPT} ${SHARE_COMPILE_OPT})
+set_target_properties(test_common PROPERTIES LINK_FLAGS ${COMMON_LINK_OPT})
+target_link_libraries(test_common PRIVATE ${COMMON_LINK_LIB} ${SERVER_LINK_LIB})
+SET_TARGET_PROPERTIES(test_common PROPERTIES OUTPUT_NAME "test")
+
+# target etmemd cslide share
+target_compile_options(cslide_dep PRIVATE ${COMMON_COMPILE_OPT} ${SHARE_COMPILE_OPT})
+set_target_properties(cslide_dep PROPERTIES LINK_FLAGS ${COMMON_LINK_OPT})
+target_link_libraries(cslide_dep PRIVATE ${COMMON_LINK_LIB} ${SERVER_LINK_LIB})
+
diff --git a/etmem/test/common/test_common.c b/etmem/test/common/test_common.c
new file mode 100644
index 0000000..4551177
--- /dev/null
+++ b/etmem/test/common/test_common.c
@@ -0,0 +1,327 @@
+/******************************************************************************
+ * Copyright (c) Huawei Technologies Co., Ltd. 2019-2021. All rights reserved.
+ * etmem is licensed under the Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ * http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+ * PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * Author: louhongxiang
+ * Create: 2021-11-19
+ * Description: This is a header file of the export data structure definition for page.
+ ******************************************************************************/
+
+#include <stdio.h>
+#include <numa.h>
+
+#include <CUnit/Basic.h>
+#include <CUnit/Automated.h>
+#include <CUnit/Console.h>
+
+#include "etmemd_project.h"
+
+#include "test_common.h"
+
+#define FIRST_COLD_NODE_INDEX 2
+#define FIRST_HOT_NODE_INDEX 0
+#define SECOND_COLD_NODE_INDEX 6
+#define SECOND_HOT_NODE_INDEX 4
+
+GKeyFile *load_config(const char *file_name)
+{
+ GKeyFile *config = NULL;
+
+ config = g_key_file_new();
+ CU_ASSERT_PTR_NOT_NULL(config);
+ CU_ASSERT_NOT_EQUAL(g_key_file_load_from_file(config, file_name, G_KEY_FILE_NONE, NULL), FALSE);
+ return config;
+}
+
+void unload_config(GKeyFile *config)
+{
+ g_key_file_free(config);
+}
+
+void construct_proj_file(struct proj_test_param *param)
+{
+ FILE *file = NULL;
+
+ file = fopen(param->file_name, "w+");
+ CU_ASSERT_PTR_NOT_NULL(file);
+ CU_ASSERT_NOT_EQUAL(fprintf(file, "[project]\n"), -1);
+ if (param->proj_name != NULL) {
+ CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_NAME, param->proj_name), -1);
+ }
+ if (param->interval != NULL) {
+ CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_INTERVAL, param->interval), -1);
+ }
+ if (param->loop != NULL) {
+ CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_LOOP, param->loop), -1);
+ }
+ if (param->sleep != NULL) {
+ CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_SLEEP, param->sleep), -1);
+ }
+ fclose(file);
+}
+
+GKeyFile *construct_proj_config(struct proj_test_param *param)
+{
+ construct_proj_file(param);
+
+ return load_config(param->file_name);
+}
+
+void destroy_proj_config(GKeyFile *config)
+{
+ unload_config(config);
+}
+
+void init_proj_param(struct proj_test_param *param)
+{
+ param->sleep = "1";
+ param->interval = "1";
+ param->loop = "1";
+ param->file_name = TMP_PROJ_CONFIG;
+ param->proj_name = DEFAULT_PROJ;
+ param->expt = OPT_SUCCESS;
+}
+
+void do_add_proj_test(struct proj_test_param * param)
+{
+ GKeyFile *config = NULL;
+
+ config = construct_proj_config(param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), param->expt);
+ destroy_proj_config(config);
+}
+
+void do_rm_proj_test(struct proj_test_param *param)
+{
+ GKeyFile *config = NULL;
+
+ config = load_config(param->file_name);
+ CU_ASSERT_EQUAL(etmemd_project_remove(config), param->expt);
+ unload_config(config);
+}
+
+void construct_eng_file(struct eng_test_param *param)
+{
+ FILE *file = NULL;
+
+ file = fopen(param->file_name, "w+");
+ CU_ASSERT_PTR_NOT_NULL(file);
+ CU_ASSERT_NOT_EQUAL(fprintf(file, "[engine]\n"), -1);
+ if (param->name != NULL) {
+ CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_NAME, param->name), -1);
+ }
+ if (param->proj != NULL) {
+ CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_PROJ, param->proj), -1);
+ }
+ fclose(file);
+}
+
+GKeyFile *construct_eng_config(struct eng_test_param *param)
+{
+ construct_eng_file(param);
+
+ return load_config(param->file_name);
+}
+
+void destroy_eng_config(GKeyFile *config)
+{
+ unload_config(config);
+}
+
+void init_task_param(struct task_test_param *param, const char *eng)
+{
+ param->name = DEFAULT_TASK;
+ param->proj = DEFAULT_PROJ;
+ param->eng = eng;
+ param->type = "pid";
+ param->value = "1";
+ param->file_name = TMP_TASK_CONFIG;
+}
+
+void construct_task_file(struct task_test_param *param)
+{
+ FILE *file = NULL;
+
+ file = fopen(param->file_name, "w+");
+ CU_ASSERT_PTR_NOT_NULL(file);
+ CU_ASSERT_NOT_EQUAL(fprintf(file, "[task]\n"), -1);
+ if (param->name != NULL) {
+ CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_NAME, param->name), -1);
+ }
+ if (param->proj != NULL) {
+ CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_PROJ, param->name), -1);
+ }
+ if (param->eng != NULL) {
+ CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_ENG, param->name), -1);
+ }
+ if (param->type != NULL) {
+ CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_TYPE, param->name), -1);
+ }
+ if (param->value != NULL) {
+ CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_VALUE, param->name), -1);
+ }
+ fclose(file);
+}
+
+void init_slide_task(struct slide_task_test_param *param)
+{
+ init_task_param(&param->task_param, "slide");
+ param->max_threads = "1";
+ param->T = "1";
+}
+
+void add_slide_task(struct slide_task_test_param *param)
+{
+ FILE *file = NULL;
+ const char *file_name = param->task_param.file_name;
+
+ file = fopen(file_name, "a+");
+ CU_ASSERT_PTR_NOT_NULL(file);
+ if (param->max_threads != NULL) {
+ CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_MAX_THREADS, param->max_threads), -1);
+ }
+ if (param->T != NULL) {
+ CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_T, param->T), -1);
+ }
+ fclose(file);
+}
+
+GKeyFile *construct_slide_task_config(struct slide_task_test_param *param)
+{
+ struct task_test_param *task_param = &param->task_param;
+
+ construct_task_file(task_param);
+ add_slide_task(param);
+
+ return load_config(task_param->file_name);
+}
+
+void destroy_slide_task_config(GKeyFile *config)
+{
+ unload_config(config);
+}
+
+void init_slide_eng(struct eng_test_param *param)
+{
+ param->name = "slide";
+ param->proj = DEFAULT_PROJ;
+ param->file_name = TMP_ENG_CONFIG;
+}
+
+static char *get_node_pair(void)
+{
+ int node_num = numa_num_configured_nodes();
+
+ switch (node_num) {
+ case ONE_NODE_PAIR:
+ return "0,1";
+ case TWO_NODE_PAIR:
+ return "0,2;1,3";
+ case THREE_NODE_PAIR:
+ return "0,3;1,4;2,5";
+ default:
+ return NULL;
+ }
+}
+
+int get_first_cold_node(struct cslide_eng_test_param *param)
+{
+ return param->node_pair[FIRST_COLD_NODE_INDEX] - '0';
+}
+
+int get_first_hot_node(struct cslide_eng_test_param *param)
+{
+ return param->node_pair[FIRST_HOT_NODE_INDEX] - '0';
+}
+
+int get_second_cold_node(struct cslide_eng_test_param *param)
+{
+ return param->node_pair[SECOND_COLD_NODE_INDEX] - '0';
+}
+
+int get_second_hot_node(struct cslide_eng_test_param *param)
+{
+ return param->node_pair[SECOND_HOT_NODE_INDEX] - '0';
+}
+
+void init_cslide_eng(struct cslide_eng_test_param *param)
+{
+ param->eng_param.name = "cslide";
+ param->eng_param.proj = DEFAULT_PROJ;
+ param->eng_param.file_name = TMP_ENG_CONFIG;
+ param->node_pair = get_node_pair();
+ param->hot_threshold = "2";
+ param->node_mig_quota = "1024";
+ param->node_hot_reserve = "1024";
+}
+
+void add_cslide_eng(struct cslide_eng_test_param *param)
+{
+ FILE *file = NULL;
+ const char *file_name = param->eng_param.file_name;
+
+ file = fopen(file_name, "a+");
+ CU_ASSERT_PTR_NOT_NULL(file);
+ CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_NODE_PAIR, param->node_pair), -1);
+ CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_THRESH, param->hot_threshold), -1);
+ CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_QUOTA, param->node_mig_quota), -1);
+ CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_RESV, param->node_hot_reserve), -1);
+ fclose(file);
+}
+
+GKeyFile *construct_cslide_eng_config(struct cslide_eng_test_param *param)
+{
+ struct eng_test_param *eng_param = &param->eng_param;
+
+ construct_eng_file(eng_param);
+ add_cslide_eng(param);
+
+ return load_config(eng_param->file_name);
+}
+
+void destroy_cslide_eng_config(GKeyFile *config)
+{
+ unload_config(config);
+}
+
+void init_cslide_task(struct cslide_task_test_param *param)
+{
+ init_task_param(&param->task_param, "cslide");
+ param->vm_flags = "ht";
+ param->anon_only = "no";
+ param->ign_host = "yes";
+}
+
+void add_cslide_task(struct cslide_task_test_param *param)
+{
+ FILE *file = NULL;
+ const char *file_name = param->task_param.file_name;
+
+ file = fopen(file_name, "a+");
+ CU_ASSERT_PTR_NOT_NULL(file);
+ CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_VM_FLAGS, param->vm_flags), -1);
+ CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_ANON_ONLY, param->anon_only), -1);
+ CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_IGN_HOST, param->ign_host), -1);
+ fclose(file);
+}
+
+GKeyFile *construct_cslide_task_config(struct cslide_task_test_param *param)
+{
+ struct task_test_param *task_param = &param->task_param;
+
+ construct_task_file(task_param);
+ add_cslide_task(param);
+
+ return load_config(task_param->file_name);
+}
+
+void destroy_cslide_task_config(GKeyFile *config)
+{
+ unload_config(config);
+}
diff --git a/etmem/test/common/test_common.h b/etmem/test/common/test_common.h
new file mode 100644
index 0000000..009c458
--- /dev/null
+++ b/etmem/test/common/test_common.h
@@ -0,0 +1,138 @@
+/******************************************************************************
+ * Copyright (c) Huawei Technologies Co., Ltd. 2019-2021. All rights reserved.
+ * etmem is licensed under the Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ * http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+ * PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * Author: louhongxiang
+ * Create: 2021-11-19
+ * Description: This is a header file of the export data structure definition for page.
+ ******************************************************************************/
+
+#ifndef TEST_COMMON_H
+#define TEST_COMMON_H
+
+#include <glib.h>
+
+#include "etmemd_project.h"
+
+#define CONFIG_NAME "name=%s\n"
+#define CONFIG_INTERVAL "interval=%s\n"
+#define CONFIG_LOOP "loop=%s\n"
+#define CONFIG_SLEEP "sleep=%s\n"
+#define TMP_PROJ_CONFIG "proj_tmp.config"
+#define DEFAULT_PROJ "default_proj"
+
+#define CONFIG_PROJ "project=%s\n"
+#define TMP_ENG_CONFIG "eng_tmp.config"
+
+#define CONFIG_ENG "engine=%s\n"
+#define CONFIG_TYPE "type=%s\n"
+#define CONFIG_VALUE "value=%s\n"
+#define TMP_TASK_CONFIG "task_tmp.config"
+#define DEFAULT_TASK "default_task"
+
+#define CONFIG_MAX_THREADS "max_threads=%s\n"
+#define CONFIG_T "T=%s\n"
+
+#define CONFIG_NODE_PAIR "node_pair=%s\n"
+#define CONFIG_THRESH "hot_threshold=%s\n"
+#define CONFIG_QUOTA "node_mig_quota=%s\n"
+#define CONFIG_RESV "node_hot_reserve=%s\n"
+
+#define CONFIG_VM_FLAGS "vm_flags=%s\n"
+#define CONFIG_ANON_ONLY "anon_only=%s\n"
+#define CONFIG_IGN_HOST "igno_host=%s\n"
+
+#define ONE_NODE_PAIR 2
+#define TWO_NODE_PAIR 4
+#define THREE_NODE_PAIR 5
+
+
+struct proj_test_param {
+ const char *sleep;
+ const char *interval;
+ const char *loop;
+ const char *proj_name;
+ const char *file_name;
+ enum opt_result expt;
+};
+
+struct eng_test_param {
+ const char *name;
+ const char *proj;
+ const char *file_name;
+};
+
+struct task_test_param {
+ const char *name;
+ const char *proj;
+ const char *eng;
+ const char *type;
+ const char *value;
+ const char *file_name;
+};
+
+struct slide_task_test_param {
+ struct task_test_param task_param;
+ const char *max_threads;
+ const char *T;
+};
+
+struct cslide_eng_test_param {
+ struct eng_test_param eng_param;
+ const char *node_pair;
+ const char *hot_threshold;
+ const char *node_mig_quota;
+ const char *node_hot_reserve;
+};
+
+struct cslide_task_test_param {
+ struct task_test_param task_param;
+ const char *vm_flags;
+ const char *anon_only;
+ const char *ign_host;
+};
+
+GKeyFile *load_config(const char *file_name);
+void unload_config(GKeyFile *config);
+
+void construct_proj_file(struct proj_test_param *param);
+GKeyFile *construct_proj_config(struct proj_test_param *param);
+void destroy_proj_config(GKeyFile *config);
+void init_proj_param(struct proj_test_param *param);
+void do_add_proj_test(struct proj_test_param *param);
+void do_rm_proj_test(struct proj_test_param *param);
+
+void construct_eng_file(struct eng_test_param *param);
+GKeyFile *construct_eng_config(struct eng_test_param *param);
+void destroy_eng_config(GKeyFile *config);
+
+void init_task_param(struct task_test_param *param, const char *eng);
+void construct_task_file(struct task_test_param *param);
+
+void init_slide_task(struct slide_task_test_param *param);
+void add_slide_task(struct slide_task_test_param *param);
+GKeyFile *construct_slide_task_config(struct slide_task_test_param *param);
+void destroy_slide_task_config(GKeyFile *config);
+void init_slide_eng(struct eng_test_param *param);
+
+void init_cslide_eng(struct cslide_eng_test_param *param);
+void add_cslide_eng(struct cslide_eng_test_param *param);
+GKeyFile *construct_cslide_eng_config(struct cslide_eng_test_param *param);
+void destroy_cslide_eng_config(GKeyFile *config);
+
+int get_first_cold_node(struct cslide_eng_test_param *param);
+int get_first_hot_node(struct cslide_eng_test_param *param);
+int get_second_cold_node(struct cslide_eng_test_param *param);
+int get_second_hot_node(struct cslide_eng_test_param *param);
+
+void init_cslide_task(struct cslide_task_test_param *param);
+void add_cslide_task(struct cslide_task_test_param *param);
+GKeyFile *construct_cslide_task_config(struct cslide_task_test_param *param);
+void destroy_cslide_task_config(GKeyFile *config);
+#endif
--
1.8.3.1

523
0056-add-code-of-testcase-for-etmem-project-function.patch Normal file
View File

@ -0,0 +1,523 @@
From f63083aff0d1d305079d9f0c47717faa512361f8 Mon Sep 17 00:00:00 2001
From: liubo <liubo254@huawei.com>
Date: Tue, 30 Nov 2021 09:42:50 +0800
Subject: [PATCH 05/33] add code of testcase for etmem project function
---
etmem/test/project/CMakeLists.txt | 28 ++
etmem/test/project/etmem_project_ops_llt.c | 468 +++++++++++++++++++++++++++++
2 files changed, 496 insertions(+)
create mode 100644 etmem/test/project/CMakeLists.txt
create mode 100644 etmem/test/project/etmem_project_ops_llt.c
diff --git a/etmem/test/project/CMakeLists.txt b/etmem/test/project/CMakeLists.txt
new file mode 100644
index 0000000..70cd530
--- /dev/null
+++ b/etmem/test/project/CMakeLists.txt
@@ -0,0 +1,28 @@
+# /******************************************************************************
+# * Copyright (c) Huawei Technologies Co., Ltd. 2019-2021. All rights reserved.
+# * etmem is licensed under the Mulan PSL v2.
+# * You can use this software according to the terms and conditions of the Mulan PSL v2.
+# * You may obtain a copy of Mulan PSL v2 at:
+# * http://license.coscl.org.cn/MulanPSL2
+# * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+# * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+# * PURPOSE.
+# * See the Mulan PSL v2 for more details.
+# * Author: liubo
+# * Create: 2021-11-29
+# * Description: CMakefileList for etmem_project_ops_llt to compile
+# ******************************************************************************/
+
+project(etmem)
+
+INCLUDE_DIRECTORIES(../../inc/etmem_inc)
+INCLUDE_DIRECTORIES(../../inc/etmemd_inc)
+INCLUDE_DIRECTORIES(../common)
+INCLUDE_DIRECTORIES(${GLIB2_INCLUDE_DIRS})
+
+SET(EXE etmem_project_ops_llt)
+
+add_executable(${EXE}
+etmem_project_ops_llt.c)
+
+target_link_libraries(${EXE} cunit ${BUILD_DIR}/lib/libetmemd.so ${BUILD_DIR}/lib/libtest.so pthread dl rt boundscheck numa ${GLIB2_LIBRARIES})
diff --git a/etmem/test/project/etmem_project_ops_llt.c b/etmem/test/project/etmem_project_ops_llt.c
new file mode 100644
index 0000000..edd2330
--- /dev/null
+++ b/etmem/test/project/etmem_project_ops_llt.c
@@ -0,0 +1,468 @@
+/******************************************************************************
+ * Copyright (c) Huawei Technologies Co., Ltd. 2019-2021. All rights reserved.
+ * etmem is licensed under the Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ * http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+ * PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * Author: liubo
+ * Create: 2021-11-29
+ * Description: This is a source file of the unit test for project-related commands in etmem.
+ ******************************************************************************/
+
+#include <sys/file.h>
+#include <sys/sysinfo.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <limits.h>
+#include <glib.h>
+
+#include "etmemd_project.h"
+#include "etmemd_file.h"
+#include "etmemd_common.h"
+#include "securec.h"
+
+#include "test_common.h"
+
+#include <CUnit/Basic.h>
+#include <CUnit/Automated.h>
+#include <CUnit/Console.h>
+
+#define PROJECT_ADD_TEST_MAX_NUM 50
+
+static struct proj_test_param g_proj_test_param;
+
+static void etmem_pro_add_name(void)
+{
+ const char *project_name_long = "project name cannot longer than 32 ppmpppppppppppppppppppppppppppppppppppppppppppppp";
+ GKeyFile *config = NULL;
+ struct proj_test_param param;
+
+ init_proj_param(&param);
+
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_SUCCESS);
+ destroy_proj_config(config);
+
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_PRO_EXISTED);
+ destroy_proj_config(config);
+
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_remove(config), OPT_SUCCESS);
+ destroy_proj_config(config);
+
+ param.proj_name = "";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_INVAL);
+ destroy_proj_config(config);
+
+ param.proj_name = project_name_long;
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_INVAL);
+ destroy_proj_config(config);
+
+ param.proj_name = DEFAULT_PROJ;
+}
+
+static void etmem_pro_add_interval(void)
+{
+ struct proj_test_param param;
+ GKeyFile *config = NULL;
+
+ init_proj_param(&param);
+
+ param.interval = "0";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_INVAL);
+ destroy_proj_config(config);
+
+ param.interval = "1";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_SUCCESS);
+ CU_ASSERT_EQUAL(etmemd_project_remove(config), OPT_SUCCESS);
+ destroy_proj_config(config);
+
+ param.interval = "2";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_SUCCESS);
+ CU_ASSERT_EQUAL(etmemd_project_remove(config), OPT_SUCCESS);
+ destroy_proj_config(config);
+
+ param.interval = "1199";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_SUCCESS);
+ CU_ASSERT_EQUAL(etmemd_project_remove(config), OPT_SUCCESS);
+ destroy_proj_config(config);
+
+ param.interval = "1200";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_SUCCESS);
+ CU_ASSERT_EQUAL(etmemd_project_remove(config), OPT_SUCCESS);
+ destroy_proj_config(config);
+
+ param.interval = "1201";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_INVAL);
+ destroy_proj_config(config);
+
+ param.interval = "abc";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_INVAL);
+ destroy_proj_config(config);
+}
+
+static void etmem_pro_add_loop(void)
+{
+ struct proj_test_param param;
+ GKeyFile *config = NULL;
+
+ init_proj_param(&param);
+
+ param.loop = "0";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_INVAL);
+ destroy_proj_config(config);
+
+ param.loop = "1";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_SUCCESS);
+ CU_ASSERT_EQUAL(etmemd_project_remove(config), OPT_SUCCESS);
+ destroy_proj_config(config);
+
+ param.loop = "2";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_SUCCESS);
+ CU_ASSERT_EQUAL(etmemd_project_remove(config), OPT_SUCCESS);
+ destroy_proj_config(config);
+
+ param.loop = "119";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_SUCCESS);
+ CU_ASSERT_EQUAL(etmemd_project_remove(config), OPT_SUCCESS);
+ destroy_proj_config(config);
+
+ param.loop = "120";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_SUCCESS);
+ CU_ASSERT_EQUAL(etmemd_project_remove(config), OPT_SUCCESS);
+ destroy_proj_config(config);
+
+ param.loop = "121";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_INVAL);
+ destroy_proj_config(config);
+
+ param.loop = "abc";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_INVAL);
+ destroy_proj_config(config);
+}
+
+static void etmem_pro_add_sleep(void)
+{
+ struct proj_test_param param;
+ GKeyFile *config = NULL;
+
+ init_proj_param(&param);
+
+ param.sleep = "0";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_INVAL);
+ destroy_proj_config(config);
+
+ param.sleep = "1";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_SUCCESS);
+ CU_ASSERT_EQUAL(etmemd_project_remove(config), OPT_SUCCESS);
+ destroy_proj_config(config);
+
+ param.sleep = "2";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_SUCCESS);
+ CU_ASSERT_EQUAL(etmemd_project_remove(config), OPT_SUCCESS);
+ destroy_proj_config(config);
+
+ param.sleep = "1199";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_SUCCESS);
+ CU_ASSERT_EQUAL(etmemd_project_remove(config), OPT_SUCCESS);
+ destroy_proj_config(config);
+
+ param.sleep = "1200";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_SUCCESS);
+ CU_ASSERT_EQUAL(etmemd_project_remove(config), OPT_SUCCESS);
+ destroy_proj_config(config);
+
+ param.sleep = "1201";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_INVAL);
+ destroy_proj_config(config);
+
+ param.sleep = "wrong sleep type";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_INVAL);
+ destroy_proj_config(config);
+}
+
+static void etmem_pro_lack_loop(void)
+{
+ struct proj_test_param param;
+ GKeyFile *config = NULL;
+
+ init_proj_param(&param);
+
+ param.loop = NULL;
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_INVAL);
+ destroy_proj_config(config);
+}
+
+void test_etmem_prj_add_error(void)
+{
+ etmem_pro_add_name();
+ etmem_pro_add_interval();
+ etmem_pro_add_loop();
+ etmem_pro_add_sleep();
+ etmem_pro_lack_loop();
+}
+
+void test_etmem_prj_del_error(void)
+{
+ struct proj_test_param param;
+ GKeyFile *config = NULL;
+
+ init_proj_param(&param);
+
+ param.proj_name = "";
+ config = construct_proj_config(&param);
+ CU_ASSERT_NOT_EQUAL(etmemd_project_remove(config), OPT_SUCCESS);
+ destroy_proj_config(config);
+
+ param.proj_name = "noexist";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_remove(config), OPT_PRO_NOEXIST);
+ destroy_proj_config(config);
+}
+
+static void add_project_once(void)
+{
+ struct proj_test_param param;
+ GKeyFile *config = NULL;
+
+ init_proj_param(&param);
+
+ CU_ASSERT_EQUAL(etmemd_project_show(NULL, 0), OPT_PRO_NOEXIST);
+
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_SUCCESS);
+ destroy_proj_config(config);
+
+ CU_ASSERT_EQUAL(etmemd_project_show(NULL, 0), OPT_SUCCESS);
+
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_remove(config), OPT_SUCCESS);
+ destroy_proj_config(config);
+
+ CU_ASSERT_EQUAL(etmemd_project_show("noexist", 0), OPT_PRO_NOEXIST);
+}
+
+static int add_project_multiple(int proj_add_num)
+{
+ char project_name_str[PROJECT_NAME_MAX_LEN] = {0};
+ unsigned int project_num;
+ struct proj_test_param param;
+ GKeyFile *config = NULL;
+
+ init_proj_param(&param);
+
+ for (project_num = 0; project_num < proj_add_num; project_num++) {
+ if (snprintf_s(project_name_str, PROJECT_NAME_MAX_LEN, PROJECT_NAME_MAX_LEN - 1, "project_add_del_test_num%d",
+ project_num) <= 0) {
+ printf("get project_name wrong.\n");
+ return -1;
+ }
+ param.proj_name = project_name_str;
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_SUCCESS);
+ destroy_proj_config(config);
+ }
+
+ CU_ASSERT_EQUAL(etmemd_project_show(NULL, 0), OPT_SUCCESS);
+ CU_ASSERT_EQUAL(etmemd_project_show("project_add_del_test_num5", 0), OPT_SUCCESS);
+
+ for (project_num = 0; project_num < proj_add_num; project_num++) {
+ if (snprintf_s(project_name_str, PROJECT_NAME_MAX_LEN, PROJECT_NAME_MAX_LEN - 1, "project_add_del_test_num%d",
+ project_num) <= 0) {
+ printf("get project_name wrong.\n");
+ return -1;
+ }
+ param.proj_name = project_name_str;
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_remove(config), OPT_SUCCESS);
+ destroy_proj_config(config);
+ }
+
+ return 0;
+}
+
+void test_etmem_project_add_ok(void)
+{
+ add_project_once();
+ CU_ASSERT_EQUAL(add_project_multiple(PROJECT_ADD_TEST_MAX_NUM), 0);
+}
+
+void test_etmem_mig_start_error(void)
+{
+ struct proj_test_param param;
+
+ init_proj_param(&param);
+
+ CU_ASSERT_EQUAL(etmemd_migrate_start(NULL), OPT_INVAL);
+ CU_ASSERT_EQUAL(etmemd_migrate_start(""), OPT_PRO_NOEXIST);
+ CU_ASSERT_EQUAL(etmemd_migrate_start("etmem"), OPT_PRO_NOEXIST);
+ CU_ASSERT_EQUAL(etmemd_migrate_start("me^$%*mig"), OPT_PRO_NOEXIST);
+
+ param.proj_name = "add_for_migrate_test";
+ do_add_proj_test(&param);
+
+ CU_ASSERT_EQUAL(etmemd_migrate_start("add_for_migrate_test"), OPT_SUCCESS);
+ CU_ASSERT_EQUAL(etmemd_migrate_start("add_for_migrate_test"), OPT_PRO_STARTED);
+
+ etmemd_stop_all_projects();
+}
+
+void test_etmem_mig_stop_error(void)
+{
+ struct proj_test_param param;
+
+ init_proj_param(&param);
+
+ CU_ASSERT_EQUAL(etmemd_migrate_stop(NULL), OPT_INVAL);
+ CU_ASSERT_EQUAL(etmemd_migrate_stop(""), OPT_PRO_NOEXIST);
+ CU_ASSERT_EQUAL(etmemd_migrate_stop("ETMEM"), OPT_PRO_NOEXIST);
+ CU_ASSERT_EQUAL(etmemd_migrate_stop("ET^$%*MEM"), OPT_PRO_NOEXIST);
+
+ param.proj_name = "add_for_migrate_stop_test";
+ do_add_proj_test(&param);
+
+ CU_ASSERT_EQUAL(etmemd_migrate_start("add_for_migrate_stop_test"), OPT_SUCCESS);
+ CU_ASSERT_EQUAL(etmemd_migrate_stop("add_for_migrate_stop_test"), OPT_SUCCESS);
+ CU_ASSERT_EQUAL(etmemd_migrate_stop("add_for_migrate_stop_test"), OPT_PRO_STOPPED);
+
+ etmemd_stop_all_projects();
+}
+
+static int start_project_multiple(int proj_add_num)
+{
+ char project_name_str[PROJECT_NAME_MAX_LEN] = {0};
+ unsigned int project_num;
+ struct proj_test_param param;
+ GKeyFile *config = NULL;
+
+ init_proj_param(&param);
+
+ for (project_num = 0; project_num < proj_add_num; project_num++) {
+ if (snprintf_s(project_name_str, PROJECT_NAME_MAX_LEN, PROJECT_NAME_MAX_LEN - 1, "project_add_del_test_num%d",
+ project_num) <= 0) {
+ printf("get project_name wrong.\n");
+ return -1;
+ }
+ param.proj_name = project_name_str;
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_SUCCESS);
+ destroy_proj_config(config);
+ CU_ASSERT_EQUAL(etmemd_migrate_start(project_name_str), OPT_SUCCESS);
+ }
+
+ for (project_num = 0; project_num < proj_add_num; project_num++) {
+ if (snprintf_s(project_name_str, PROJECT_NAME_MAX_LEN, PROJECT_NAME_MAX_LEN - 1, "project_add_del_test_num%d",
+ project_num) <= 0) {
+ printf("get project_name wrong.\n");
+ return -1;
+ }
+ param.proj_name = project_name_str;
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_migrate_stop(project_name_str), OPT_SUCCESS);
+ CU_ASSERT_EQUAL(etmemd_project_remove(config), OPT_SUCCESS);
+ destroy_proj_config(config);
+ }
+
+ return 0;
+}
+
+void test_etmem_mig_start_ok(void)
+{
+ CU_ASSERT_EQUAL(start_project_multiple(1), 0);
+ CU_ASSERT_EQUAL(start_project_multiple(PROJECT_ADD_TEST_MAX_NUM), 0);
+}
+
+typedef enum {
+ CUNIT_SCREEN = 0,
+ CUNIT_XMLFILE,
+ CUNIT_CONSOLE
+} cu_run_mode;
+
+int main(int argc, const char **argv)
+{
+ CU_pSuite suite;
+ CU_pTest pTest;
+ unsigned int num_failures;
+ cu_run_mode cunit_mode = CUNIT_SCREEN;
+ int error_num;
+
+ if (argc > 1) {
+ cunit_mode = atoi(argv[1]);
+ }
+
+ if (CU_initialize_registry() != CUE_SUCCESS) {
+ return -CU_get_error();
+ }
+
+ suite = CU_add_suite("etmem_project_ops", NULL, NULL);
+ if (suite == NULL) {
+ goto ERROR;
+ }
+
+ if (CU_ADD_TEST(suite, test_etmem_prj_add_error) == NULL ||
+ CU_ADD_TEST(suite, test_etmem_prj_del_error) == NULL ||
+ CU_ADD_TEST(suite, test_etmem_project_add_ok) == NULL ||
+ CU_ADD_TEST(suite, test_etmem_mig_start_error) == NULL ||
+ CU_ADD_TEST(suite, test_etmem_mig_stop_error) == NULL ||
+ CU_ADD_TEST(suite, test_etmem_mig_start_ok) == NULL) {
+ printf("CU_ADD_TEST fail. \n");
+ goto ERROR;
+ }
+
+ switch (cunit_mode) {
+ case CUNIT_SCREEN:
+ CU_basic_set_mode(CU_BRM_VERBOSE);
+ CU_basic_run_tests();
+ break;
+ case CUNIT_XMLFILE:
+ CU_set_output_filename("etmemd_project.c");
+ CU_automated_run_tests();
+ break;
+ case CUNIT_CONSOLE:
+ CU_console_run_tests();
+ break;
+ default:
+ printf("not support cunit mode, only support: 0 or 1\n");
+ goto ERROR;
+ }
+
+ num_failures = CU_get_number_of_failures();
+ CU_cleanup_registry();
+ return num_failures;
+
+ERROR:
+ error_num = CU_get_error();
+ CU_cleanup_registry();
+ return -error_num;
+}
--
1.8.3.1

439
0057-add-test-for-export-scan.patch Normal file
View File

@ -0,0 +1,439 @@
From 50fb3c7251e423268164627db86c1c312c707e63 Mon Sep 17 00:00:00 2001
From: Kemeng Shi <shikemeng@huawei.com>
Date: Tue, 30 Nov 2021 11:11:01 +0800
Subject: [PATCH 06/33] add test for export scan
Signed-off-by: Kemeng Shi <shikemeng@huawei.com>
---
etmem/test/etmem_scan_ops_llt_test/CMakeLists.txt | 28 ++
.../etmem_scan_ops_llt_test/etmem_scan_ops_llt.c | 383 +++++++++++++++++++++
2 files changed, 411 insertions(+)
create mode 100644 etmem/test/etmem_scan_ops_llt_test/CMakeLists.txt
create mode 100644 etmem/test/etmem_scan_ops_llt_test/etmem_scan_ops_llt.c
diff --git a/etmem/test/etmem_scan_ops_llt_test/CMakeLists.txt b/etmem/test/etmem_scan_ops_llt_test/CMakeLists.txt
new file mode 100644
index 0000000..c6ff96c
--- /dev/null
+++ b/etmem/test/etmem_scan_ops_llt_test/CMakeLists.txt
@@ -0,0 +1,28 @@
+# /******************************************************************************
+# * Copyright (c) Huawei Technologies Co., Ltd. 2019-2021. All rights reserved.
+# * etmem is licensed under the Mulan PSL v2.
+# * You can use this software according to the terms and conditions of the Mulan PSL v2.
+# * You may obtain a copy of Mulan PSL v2 at:
+# * http://license.coscl.org.cn/MulanPSL2
+# * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+# * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+# * PURPOSE.
+# * See the Mulan PSL v2 for more details.
+# * Author: shikemeng
+# * Create: 2021-11-30
+# * Description: CMakefileList for etmem_scan_ops_llt_test
+# ******************************************************************************/
+
+project(etmem)
+
+INCLUDE_DIRECTORIES(../../inc/etmem_inc)
+INCLUDE_DIRECTORIES(../../inc/etmemd_inc)
+INCLUDE_DIRECTORIES(${GLIB2_INCLUDE_DIRS})
+
+SET(EXE etmem_scan_ops_llt)
+
+add_executable(etmem_scan_ops_llt
+ etmem_scan_ops_llt.c
+ )
+
+target_link_libraries(${EXE} cunit ${BUILD_DIR}/lib/libetmemd.so pthread dl rt libboundscheck numa ${GLIB2_LIBRARIES})
diff --git a/etmem/test/etmem_scan_ops_llt_test/etmem_scan_ops_llt.c b/etmem/test/etmem_scan_ops_llt_test/etmem_scan_ops_llt.c
new file mode 100644
index 0000000..1856072
--- /dev/null
+++ b/etmem/test/etmem_scan_ops_llt_test/etmem_scan_ops_llt.c
@@ -0,0 +1,383 @@
+/******************************************************************************
+ * Copyright (c) Huawei Technologies Co., Ltd. 2019-2021. All rights reserved.
+ * etmem is licensed under the Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ * http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+ * PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * Author: shikemeng
+ * Create: 2021-11-30
+ * Description: test for export scan
+ ******************************************************************************/
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <CUnit/Basic.h>
+#include <CUnit/Automated.h>
+#include <CUnit/Console.h>
+
+#include "etmemd_scan.h"
+#include "etmemd_project.h"
+#include "etmemd_engine.h"
+
+static struct task_pid *alloc_tkpid(unsigned int pid, struct task *tk)
+{
+ struct task_pid *tpid = NULL;
+
+ tpid = (struct task_pid *)calloc(1, sizeof(struct task_pid));
+ CU_ASSERT_PTR_NOT_NULL(tpid);
+ tpid->pid = pid;
+ tpid->tk = tk;
+
+ return tpid;
+}
+
+
+static struct task *alloc_tk(int loop, int sleep)
+{
+ struct task *tk = NULL;
+ struct project *proj = NULL;
+ struct engine *eng = NULL;
+
+ proj = (struct project *)calloc(1, sizeof(struct project));
+ CU_ASSERT_PTR_NOT_NULL(proj);
+
+ proj->loop = loop;
+ proj->sleep = sleep;
+
+ tk = (struct task *)calloc(1, sizeof(struct task));
+ CU_ASSERT_PTR_NOT_NULL(tk);
+
+ eng = calloc(1, sizeof(struct engine));
+ eng->name = "cslide";
+
+ eng->proj = proj;
+ tk->eng = eng;
+
+ return tk;
+}
+
+void check_vmas(struct vmas *vmas)
+{
+ CU_ASSERT_NOT_EQUAL(vmas->vma_cnt, 0);
+
+ int i;
+ struct vma *curr_vma = NULL;
+
+ curr_vma = vmas->vma_list;
+ for (i = 0; i < vmas->vma_cnt; i++) {
+ CU_ASSERT_PTR_NOT_NULL(curr_vma);
+ curr_vma = curr_vma->next;
+ }
+}
+
+static void test_get_vmas_invalid(void)
+{
+ const char *pid = "1";
+ char *vmflags_array[10] = {"rd"};
+ int vmflag_num = 1;
+ int is_anon_only = false;
+ struct vmas *vmas = NULL;
+
+ CU_ASSERT_EQUAL(etmemd_scan_init(), 0);
+
+ // non-exist pid
+ vmas = etmemd_get_vmas("0", vmflags_array, vmflag_num, is_anon_only);
+ CU_ASSERT_PTR_NULL(vmas);
+
+ // pid is NULL
+ vmas = etmemd_get_vmas(NULL, vmflags_array, vmflag_num, is_anon_only);
+ CU_ASSERT_PTR_NULL(vmas);
+
+ // pid contains invalid characters
+ vmas = etmemd_get_vmas("1-", vmflags_array, vmflag_num, is_anon_only);
+ CU_ASSERT_PTR_NULL(vmas);
+
+ // vmflags contains space
+ vmflags_array[0] = "r ";
+ vmas = etmemd_get_vmas(pid, vmflags_array, vmflag_num, is_anon_only);
+ CU_ASSERT_PTR_NULL(vmas);
+
+ // vmflags length is not 2
+ vmflags_array[0] = "r";
+ vmas = etmemd_get_vmas(pid, vmflags_array, vmflag_num, is_anon_only);
+ CU_ASSERT_PTR_NULL(vmas);
+
+ // vmflags is NULL
+ vmflags_array[0] = NULL;
+ vmas = etmemd_get_vmas(pid, vmflags_array, vmflag_num, is_anon_only);
+ CU_ASSERT_PTR_NULL(vmas);
+
+ // test free NULL
+ vmas = NULL;
+ etmemd_free_vmas(vmas);
+
+ etmemd_scan_exit();
+}
+
+
+static void test_get_vmas_valid(void)
+{
+ const char *pid = "1";
+ char *vmflags_array[10] = {"rd"};
+ int vmflag_num = 1;
+ int is_anon_only = false;
+ struct vmas *vmas = NULL;
+ struct vma *curr_vma = NULL;
+ int i;
+
+ // get vmas without init
+ vmas = etmemd_get_vmas(pid, vmflags_array, vmflag_num, is_anon_only);
+
+ CU_ASSERT_PTR_NOT_NULL(vmas);
+ check_vmas(vmas);
+
+ etmemd_free_vmas(vmas);
+
+ // get vmas with init
+ CU_ASSERT_EQUAL(etmemd_scan_init(), 0);
+
+ vmas = etmemd_get_vmas(pid, vmflags_array, vmflag_num, is_anon_only);
+
+ CU_ASSERT_PTR_NOT_NULL(vmas);
+ check_vmas(vmas);
+
+ etmemd_free_vmas(vmas);
+
+ vmas = get_vmas("1");
+ CU_ASSERT_PTR_NOT_NULL(vmas);
+ CU_ASSERT_NOT_EQUAL(vmas->vma_cnt, 0);
+
+ curr_vma = vmas->vma_list;
+ for (i = 0; i < vmas->vma_cnt; i++) {
+ CU_ASSERT_PTR_NOT_NULL(curr_vma);
+ curr_vma = curr_vma->next;
+ }
+
+ free_vmas(vmas);
+ etmemd_scan_exit();
+}
+
+static void test_get_vmas(void)
+{
+ test_get_vmas_invalid();
+ test_get_vmas_valid();
+}
+
+static void test_get_page_refs_invalid(void)
+{
+ CU_ASSERT_EQUAL(etmemd_scan_init(), 0);
+
+ const char *pid = "1";
+ char *vmflags_array[10] = {"rd"};
+ int vmflag_num = 1;
+ int is_anon_only = false;
+ struct vmas *vmas = NULL;
+ struct page_refs *page_refs = NULL;
+ int flags = SCAN_AS_HUGE | SCAN_IGN_HOST;
+
+ // free null pointer
+ etmemd_free_page_refs(page_refs);
+
+ // vmas is NULL
+ CU_ASSERT_EQUAL(etmemd_get_page_refs(vmas, pid, &page_refs, flags), -1);
+
+ // vmas address range invalid
+ vmas = (struct vmas *)calloc(1, sizeof(struct vmas));
+ CU_ASSERT_PTR_NOT_NULL(vmas);
+ vmas->vma_cnt = 1;
+
+ struct vma *vma = (struct vma *)calloc(1, sizeof(struct vma));
+ CU_ASSERT_PTR_NOT_NULL(vma);
+ vma->start = 0x0ff;
+ vma->end = 0x000;
+ vma->next = NULL;
+ vmas->vma_list = vma;
+
+ CU_ASSERT_EQUAL(etmemd_get_page_refs(vmas, pid, &page_refs, flags), -1);
+ etmemd_free_vmas(vmas);
+
+ vmas = etmemd_get_vmas(pid, vmflags_array, vmflag_num, is_anon_only);
+ CU_ASSERT_PTR_NOT_NULL(vmas);
+ check_vmas(vmas);
+
+ // pid not exist
+ CU_ASSERT_EQUAL(etmemd_get_page_refs(vmas, "0", &page_refs, flags), -1);
+ CU_ASSERT_PTR_NULL(page_refs);
+
+ // pid is NULL
+ CU_ASSERT_EQUAL(etmemd_get_page_refs(vmas, NULL, &page_refs, flags), -1);
+ CU_ASSERT_PTR_NULL(page_refs);
+
+ // pid contains invalid chars
+ CU_ASSERT_EQUAL(etmemd_get_page_refs(vmas, "--", &page_refs, flags), -1);
+ CU_ASSERT_PTR_NULL(page_refs);
+
+ etmemd_free_page_refs(page_refs);
+ etmemd_free_vmas(vmas);
+ etmemd_scan_exit();
+}
+
+static void test_get_page_refs_valid()
+{
+ CU_ASSERT_EQUAL(etmemd_scan_init(), 0);
+
+ const char *pid = "1";
+ char *vmflags_array[10] = {"rd"};
+ int vmflag_num = 1;
+ int is_anon_only = false;
+ struct vmas *vmas = NULL;
+ struct page_refs *page_refs = NULL;
+ int flags = SCAN_AS_HUGE | SCAN_IGN_HOST;
+
+ vmas = etmemd_get_vmas(pid, vmflags_array, vmflag_num, is_anon_only);
+ CU_ASSERT_PTR_NOT_NULL(vmas);
+ check_vmas(vmas);
+
+ CU_ASSERT_EQUAL(etmemd_get_page_refs(vmas, pid, &page_refs, flags), 0);
+ CU_ASSERT_PTR_NOT_NULL(page_refs);
+
+ unsigned long use_rss;
+
+ CU_ASSERT_EQUAL(get_page_refs(vmas, pid, &page_refs, &use_rss, 0), 0);
+ CU_ASSERT_PTR_NOT_NULL(page_refs);
+ CU_ASSERT_NOT_EQUAL(use_rss, 0);
+
+ etmemd_free_page_refs(page_refs);
+ etmemd_free_vmas(vmas);
+ etmemd_scan_exit();
+}
+
+static void test_get_page_refs(void)
+{
+ test_get_page_refs_invalid();
+ test_get_page_refs_valid();
+}
+
+static void test_scan_error(void)
+{
+ unsigned int pid_error = 1111111111;
+ int loop = 1;
+ int sleep = 1;
+ struct task_pid *tpid = NULL;
+ struct task *tk = NULL;
+
+ tk = alloc_tk(loop, sleep);
+ tpid = alloc_tkpid(pid_error, tk);
+
+ CU_ASSERT_PTR_NULL(etmemd_do_scan(tpid, NULL));
+ CU_ASSERT_PTR_NULL(etmemd_do_scan(tpid, tk));
+
+ free(tk);
+ free(tpid);
+}
+
+static void test_etmem_scan_ok(void)
+{
+ unsigned int pid_ok = 1;
+ int loop = 1;
+ int sleep = 1;
+ struct page_refs *page_refs = NULL;
+ struct task_pid *tpid = NULL;
+ struct task *tk = NULL;
+
+ tk = alloc_tk(loop, sleep);
+ tpid = alloc_tkpid(pid_ok, tk);
+
+ CU_ASSERT_EQUAL(etmemd_scan_init(), 0);
+
+ page_refs = etmemd_do_scan(tpid, tk);
+ CU_ASSERT_PTR_NOT_NULL(page_refs);
+ free(tk);
+ free(tpid);
+ clean_page_refs_unexpected(&page_refs);
+ CU_ASSERT_PTR_NULL(page_refs);
+ etmemd_scan_exit();
+}
+
+static void test_add_pg_to_mem_grade()
+{
+ const char *pid = "1";
+ struct vmas *vma = NULL;
+ struct page_refs *page_refs = NULL;
+ struct page_refs *list = NULL;
+
+ CU_ASSERT_EQUAL(etmemd_scan_init(), 0);
+
+ vma = get_vmas(pid);
+ CU_ASSERT_EQUAL(get_page_refs(vma, pid, &page_refs, NULL, 0), 0);
+ page_refs = add_page_refs_into_memory_grade(page_refs, &list);
+ CU_ASSERT_PTR_NOT_NULL(page_refs);
+ CU_ASSERT_PTR_NOT_NULL(list);
+
+ free(list);
+ etmemd_free_page_refs(page_refs);
+ free_vmas(vma);
+ etmemd_scan_exit();
+}
+
+typedef enum {
+ CUNIT_SCREEN = 0,
+ CUNIT_XMLFILE,
+ CUNIT_CONSOLE
+} cu_run_mode;
+
+int main(int argc, const char **argv)
+{
+ CU_pSuite suite;
+ CU_pTest pTest;
+ unsigned int num_failures;
+ cu_run_mode cunit_mode = CUNIT_SCREEN;
+ int error_num;
+
+ if (argc > 1) {
+ cunit_mode = atoi(argv[1]);
+ }
+
+ if (CU_initialize_registry() != CUE_SUCCESS) {
+ return CU_get_error();
+ }
+
+ suite = CU_add_suite("etmem_scan_ops", NULL, NULL);
+ if (suite == NULL) {
+ goto ERROR;
+ }
+
+ if (CU_ADD_TEST(suite, test_get_vmas) == NULL ||
+ CU_ADD_TEST(suite, test_get_page_refs) == NULL ||
+ CU_ADD_TEST(suite, test_scan_error) == NULL ||
+ CU_ADD_TEST(suite, test_etmem_scan_ok) == NULL ||
+ CU_ADD_TEST(suite, test_add_pg_to_mem_grade) == NULL) {
+ goto ERROR;
+ }
+
+ switch (cunit_mode) {
+ case CUNIT_SCREEN:
+ CU_basic_set_mode(CU_BRM_VERBOSE);
+ CU_basic_run_tests();
+ break;
+ case CUNIT_XMLFILE:
+ CU_set_output_filename("etmemd_scan.c");
+ CU_automated_run_tests();
+ break;
+ case CUNIT_CONSOLE:
+ CU_console_run_tests();
+ break;
+ default:
+ printf("not support cunit mode, only support: 0 or 1\n");
+ goto ERROR;
+ }
+
+ num_failures = CU_get_number_of_failures();
+ CU_cleanup_registry();
+ return num_failures;
+
+ERROR:
+ error_num = CU_get_error();
+ CU_cleanup_registry();
+ return -error_num;
+}
--
1.8.3.1

1436
0058-add-code-of-testcase-for-etmem-common-function.patch Normal file
View File

File diff suppressed because it is too large Load Diff

253
0059-add-code-of-testcase-for-etmem-log-ops.patch Normal file
View File

@ -0,0 +1,253 @@
From 531e313796c9bddc1571f78e858c5bc431b65068 Mon Sep 17 00:00:00 2001
From: liubo <liubo254@huawei.com>
Date: Tue, 14 Dec 2021 11:09:51 +0800
Subject: [PATCH 08/33] add code of testcase for etmem log ops
---
.../test/etmem_common_func_llt_test/CMakeLists.txt | 3 +-
.../etmem_common_func_llt.c | 3 +-
etmem/test/etmem_log_ops_llt_test/CMakeLists.txt | 26 +++++
.../etmem_log_ops_llt_test/etmem_log_ops_llt.c | 112 +++++++++++++++++++++
.../test/etmem_project_ops_llt_test/CMakeLists.txt | 3 +-
.../etmem_project_ops_llt.c | 3 +-
etmem/test/etmem_scan_ops_llt_test/CMakeLists.txt | 4 +-
.../etmem_scan_ops_llt_test/etmem_scan_ops_llt.c | 3 +-
8 files changed, 147 insertions(+), 10 deletions(-)
create mode 100644 etmem/test/etmem_log_ops_llt_test/CMakeLists.txt
create mode 100644 etmem/test/etmem_log_ops_llt_test/etmem_log_ops_llt.c
diff --git a/etmem/test/etmem_common_func_llt_test/CMakeLists.txt b/etmem/test/etmem_common_func_llt_test/CMakeLists.txt
index be3b365..205d460 100644
--- a/etmem/test/etmem_common_func_llt_test/CMakeLists.txt
+++ b/etmem/test/etmem_common_func_llt_test/CMakeLists.txt
@@ -21,7 +21,6 @@ INCLUDE_DIRECTORIES(${GLIB2_INCLUDE_DIRS})
SET(EXE etmem_common_func_llt)
-add_executable(${EXE}
-etmem_common_func_llt.c)
+add_executable(${EXE} etmem_common_func_llt.c)
target_link_libraries(${EXE} cunit ${BUILD_DIR}/lib/libetmemd.so pthread dl rt boundscheck numa ${GLIB2_LIBRARIES})
diff --git a/etmem/test/etmem_common_func_llt_test/etmem_common_func_llt.c b/etmem/test/etmem_common_func_llt_test/etmem_common_func_llt.c
index 2bb5b11..f195d4d 100644
--- a/etmem/test/etmem_common_func_llt_test/etmem_common_func_llt.c
+++ b/etmem/test/etmem_common_func_llt_test/etmem_common_func_llt.c
@@ -300,7 +300,8 @@ int main(int argc, const char **argv)
CU_console_run_tests();
break;
default:
- printf("not support cunit mode, only support: 0 or 1\n");
+ printf("not support cunit mode, only support: "
+ "0 for CUNIT_SCREEN, 1 for CUNIT_XMLFILE, 2 for CUNIT_CONSOLE\n");
goto ERROR;
}
diff --git a/etmem/test/etmem_log_ops_llt_test/CMakeLists.txt b/etmem/test/etmem_log_ops_llt_test/CMakeLists.txt
new file mode 100644
index 0000000..322fe0f
--- /dev/null
+++ b/etmem/test/etmem_log_ops_llt_test/CMakeLists.txt
@@ -0,0 +1,26 @@
+# /******************************************************************************
+# * Copyright (c) Huawei Technologies Co., Ltd. 2019-2021. All rights reserved.
+# * etmem is licensed under the Mulan PSL v2.
+# * You can use this software according to the terms and conditions of the Mulan PSL v2.
+# * You may obtain a copy of Mulan PSL v2 at:
+# * http://license.coscl.org.cn/MulanPSL2
+# * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+# * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+# * PURPOSE.
+# * See the Mulan PSL v2 for more details.
+# * Author: liubo
+# * Create: 2021-12-10
+# * Description: CMakefileList for etmem_log_ops_llt to compile
+# ******************************************************************************/
+
+project(etmem)
+
+INCLUDE_DIRECTORIES(../../inc/etmem_inc)
+INCLUDE_DIRECTORIES(../../inc/etmemd_inc)
+INCLUDE_DIRECTORIES(${GLIB2_INCLUDE_DIRS})
+
+SET(EXE etmem_log_ops_llt)
+
+add_executable(${EXE} etmem_log_ops_llt.c)
+
+target_link_libraries(${EXE} cunit ${BUILD_DIR}/lib/libetmemd.so pthread dl rt boundscheck numa ${GLIB2_LIBRARIES})
diff --git a/etmem/test/etmem_log_ops_llt_test/etmem_log_ops_llt.c b/etmem/test/etmem_log_ops_llt_test/etmem_log_ops_llt.c
new file mode 100644
index 0000000..e9a7402
--- /dev/null
+++ b/etmem/test/etmem_log_ops_llt_test/etmem_log_ops_llt.c
@@ -0,0 +1,112 @@
+/******************************************************************************
+ * Copyright (c) Huawei Technologies Co., Ltd. 2019-2021. All rights reserved.
+ * etmem is licensed under the Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ * http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+ * PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * Author: liubo
+ * Create: 2021-12-10
+ * Description: This is a source file of the unit test for log functions in etmem.
+ ******************************************************************************/
+
+#include <sys/file.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "etmemd_log.h"
+
+#include <CUnit/Basic.h>
+#include <CUnit/Automated.h>
+#include <CUnit/Console.h>
+
+#define ETMEMD_LOG_WRONG (-1)
+
+static void test_basic_log_level(void)
+{
+ CU_ASSERT_EQUAL(etmemd_init_log_level(ETMEMD_LOG_WRONG), -1);
+ CU_ASSERT_EQUAL(etmemd_init_log_level(ETMEMD_LOG_DEBUG), 0);
+ CU_ASSERT_EQUAL(etmemd_init_log_level(ETMEMD_LOG_INFO), 0);
+ CU_ASSERT_EQUAL(etmemd_init_log_level(ETMEMD_LOG_WARN), 0);
+ CU_ASSERT_EQUAL(etmemd_init_log_level(ETMEMD_LOG_ERR), 0);
+ CU_ASSERT_EQUAL(etmemd_init_log_level(ETMEMD_LOG_INVAL), -1);
+}
+
+static void test_etmem_log_print(void)
+{
+ CU_ASSERT_EQUAL(etmemd_init_log_level(ETMEMD_LOG_DEBUG), 0);
+ etmemd_log(ETMEMD_LOG_DEBUG, "test_etmem_log_debug_level\n");
+ CU_ASSERT_EQUAL(etmemd_init_log_level(ETMEMD_LOG_INFO), 0);
+ etmemd_log(ETMEMD_LOG_INFO, "test_etmem_log_info_level\n");
+ CU_ASSERT_EQUAL(etmemd_init_log_level(ETMEMD_LOG_WARN), 0);
+ etmemd_log(ETMEMD_LOG_WARN, "test_etmem_log_warn_level\n");
+ CU_ASSERT_EQUAL(etmemd_init_log_level(ETMEMD_LOG_ERR), 0);
+ etmemd_log(ETMEMD_LOG_ERR, "test_etmem_log_error_level\n");
+ CU_ASSERT_EQUAL(etmemd_init_log_level(ETMEMD_LOG_INVAL), -1);
+ etmemd_log(ETMEMD_LOG_INVAL, "test_etmem_log_interval_level\n");
+}
+
+typedef enum {
+ CUNIT_SCREEN = 0,
+ CUNIT_XMLFILE,
+ CUNIT_CONSOLE
+} cu_run_mode;
+
+int main(int argc, const char **argv)
+{
+ CU_pSuite suite;
+ CU_pTest pTest;
+ unsigned int num_failures;
+ cu_run_mode cunit_mode = CUNIT_SCREEN;
+ int error_num;
+
+ if (argc > 1) {
+ cunit_mode = atoi(argv[1]);
+ }
+
+ if (CU_initialize_registry() != CUE_SUCCESS) {
+ return -CU_get_error();
+ }
+
+ suite = CU_add_suite("etmem_log_ops", NULL, NULL);
+ if (suite == NULL) {
+ goto ERROR;
+ }
+
+ if (CU_ADD_TEST(suite, test_basic_log_level) == NULL ||
+ CU_ADD_TEST(suite, test_etmem_log_print) == NULL) {
+ printf("CU_ADD_TEST fail. \n");
+ goto ERROR;
+ }
+
+ switch (cunit_mode) {
+ case CUNIT_SCREEN:
+ CU_basic_set_mode(CU_BRM_VERBOSE);
+ CU_basic_run_tests();
+ break;
+ case CUNIT_XMLFILE:
+ CU_set_output_filename("etmemd_log.c");
+ CU_automated_run_tests();
+ break;
+ case CUNIT_CONSOLE:
+ CU_console_run_tests();
+ break;
+ default:
+ printf("not support cunit mode, only support: "
+ "0 for CUNIT_SCREEN, 1 for CUNIT_XMLFILE, 2 for CUNIT_CONSOLE\n");
+ goto ERROR;
+ }
+
+ num_failures = CU_get_number_of_failures();
+ CU_cleanup_registry();
+ return num_failures;
+
+ERROR:
+ error_num = CU_get_error();
+ CU_cleanup_registry();
+ return -error_num;
+}
diff --git a/etmem/test/etmem_project_ops_llt_test/CMakeLists.txt b/etmem/test/etmem_project_ops_llt_test/CMakeLists.txt
index 70cd530..ff3f310 100644
--- a/etmem/test/etmem_project_ops_llt_test/CMakeLists.txt
+++ b/etmem/test/etmem_project_ops_llt_test/CMakeLists.txt
@@ -22,7 +22,6 @@ INCLUDE_DIRECTORIES(${GLIB2_INCLUDE_DIRS})
SET(EXE etmem_project_ops_llt)
-add_executable(${EXE}
-etmem_project_ops_llt.c)
+add_executable(${EXE} etmem_project_ops_llt.c)
target_link_libraries(${EXE} cunit ${BUILD_DIR}/lib/libetmemd.so ${BUILD_DIR}/lib/libtest.so pthread dl rt boundscheck numa ${GLIB2_LIBRARIES})
diff --git a/etmem/test/etmem_project_ops_llt_test/etmem_project_ops_llt.c b/etmem/test/etmem_project_ops_llt_test/etmem_project_ops_llt.c
index edd2330..a01e8e8 100644
--- a/etmem/test/etmem_project_ops_llt_test/etmem_project_ops_llt.c
+++ b/etmem/test/etmem_project_ops_llt_test/etmem_project_ops_llt.c
@@ -453,7 +453,8 @@ int main(int argc, const char **argv)
CU_console_run_tests();
break;
default:
- printf("not support cunit mode, only support: 0 or 1\n");
+ printf("not support cunit mode, only support: "
+ "0 for CUNIT_SCREEN, 1 for CUNIT_XMLFILE, 2 for CUNIT_CONSOLE\n");
goto ERROR;
}
diff --git a/etmem/test/etmem_scan_ops_llt_test/CMakeLists.txt b/etmem/test/etmem_scan_ops_llt_test/CMakeLists.txt
index c6ff96c..b5378b8 100644
--- a/etmem/test/etmem_scan_ops_llt_test/CMakeLists.txt
+++ b/etmem/test/etmem_scan_ops_llt_test/CMakeLists.txt
@@ -21,8 +21,6 @@ INCLUDE_DIRECTORIES(${GLIB2_INCLUDE_DIRS})
SET(EXE etmem_scan_ops_llt)
-add_executable(etmem_scan_ops_llt
- etmem_scan_ops_llt.c
- )
+add_executable(${EXE} etmem_scan_ops_llt.c)
target_link_libraries(${EXE} cunit ${BUILD_DIR}/lib/libetmemd.so pthread dl rt libboundscheck numa ${GLIB2_LIBRARIES})
diff --git a/etmem/test/etmem_scan_ops_llt_test/etmem_scan_ops_llt.c b/etmem/test/etmem_scan_ops_llt_test/etmem_scan_ops_llt.c
index 1856072..0cd2ecc 100644
--- a/etmem/test/etmem_scan_ops_llt_test/etmem_scan_ops_llt.c
+++ b/etmem/test/etmem_scan_ops_llt_test/etmem_scan_ops_llt.c
@@ -368,7 +368,8 @@ int main(int argc, const char **argv)
CU_console_run_tests();
break;
default:
- printf("not support cunit mode, only support: 0 or 1\n");
+ printf("not support cunit mode, only support: "
+ "0 for CUNIT_SCREEN, 1 for CUNIT_XMLFILE, 2 for CUNIT_CONSOLE\n");
goto ERROR;
}
--
1.8.3.1

29
0060-add-make-install-support-to-CMakeList.patch Normal file
View File

@ -0,0 +1,29 @@
From 31731fdc3fbd8afd8daeba2138344568cbd6a238 Mon Sep 17 00:00:00 2001
From: liubo <liubo254@huawei.com>
Date: Tue, 21 Dec 2021 21:16:52 +0800
Subject: [PATCH 10/33] add make install support to CMakeList
---
etmem/CMakeLists.txt | 9 +++++++++
1 file changed, 9 insertions(+)
diff --git a/etmem/CMakeLists.txt b/etmem/CMakeLists.txt
index b5eb83e..9fba791 100644
--- a/etmem/CMakeLists.txt
+++ b/etmem/CMakeLists.txt
@@ -123,3 +123,12 @@ if( ${ARCHITECTURE} STREQUAL "aarch64" )
else()
target_compile_options(etmemd_scan PRIVATE -march=core-avx-i -m64)
endif()
+
+install(TARGETS etmem etmemd
+ PERMISSIONS OWNER_READ OWNER_EXECUTE
+ RUNTIME DESTINATION /usr/bin)
+
+install(DIRECTORY ${PROJECT_SOURCE_DIR}/conf/
+ DIRECTORY_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE
+ FILE_PERMISSIONS OWNER_READ OWNER_WRITE
+ DESTINATION /etc/etmem)
--
1.8.3.1

1315
0061-add-region-scan.patch Normal file
View File

File diff suppressed because it is too large Load Diff

58
0062-fix-etmem-build-problem.patch Normal file
View File

@ -0,0 +1,58 @@
From 37264d5a2f7fe27092b0f8d2e834a70e3108a68d Mon Sep 17 00:00:00 2001
From: liubo <liubo254@huawei.com>
Date: Sat, 15 Jan 2022 15:01:47 +0800
Subject: [PATCH 12/33] fix etmem build problem
---
etmem/src/etmemd_src/etmemd_memdcd.c | 9 ++++++---
1 file changed, 6 insertions(+), 3 deletions(-)
diff --git a/etmem/src/etmemd_src/etmemd_memdcd.c b/etmem/src/etmemd_src/etmemd_memdcd.c
index 28590e2..7e2f657 100644
--- a/etmem/src/etmemd_src/etmemd_memdcd.c
+++ b/etmem/src/etmemd_src/etmemd_memdcd.c
@@ -243,6 +243,7 @@ static struct page_refs *memdcd_do_scan(const struct task_pid *tpid, const struc
int ret = 0;
char pid[PID_STR_MAX_LEN] = {0};
char *us = "us";
+ struct page_scan *page_scan = NULL;
if(tpid == NULL) {
etmemd_log(ETMEMD_LOG_ERR, "task pid is null\n");
@@ -254,6 +255,8 @@ static struct page_refs *memdcd_do_scan(const struct task_pid *tpid, const struc
return NULL;
}
+ page_scan = (struct page_scan *)tk->eng->proj->scan_param;
+
if (snprintf_s(pid, PID_STR_MAX_LEN, PID_STR_MAX_LEN - 1, "%u", tpid->pid) <= 0) {
etmemd_log(ETMEMD_LOG_ERR, "snprintf pid fail %u", tpid->pid);
return NULL;
@@ -266,7 +269,7 @@ static struct page_refs *memdcd_do_scan(const struct task_pid *tpid, const struc
}
/* loop for scanning idle_pages to get result of memory access. */
- for (i = 0; i < tk->eng->proj->loop; i++) {
+ for (i = 0; i < page_scan->loop; i++) {
ret = get_page_refs(vmas, pid, &page_refs, NULL, 0);
if (ret != 0) {
etmemd_log(ETMEMD_LOG_ERR, "scan operation failed\n");
@@ -275,7 +278,7 @@ static struct page_refs *memdcd_do_scan(const struct task_pid *tpid, const struc
page_refs = NULL;
break;
}
- sleep((unsigned)tk->eng->proj->sleep);
+ sleep((unsigned)page_scan->sleep);
}
free_vmas(vmas);
@@ -419,4 +422,4 @@ int fill_engine_type_memdcd(struct engine *eng, GKeyFile *config)
eng->engine_type = MEMDCD_ENGINE;
eng->name = "memdcd";
return 0;
-}
\ No newline at end of file
+}
--
1.8.3.1

864
0063-etmem-add-code-of-testcase.patch Normal file
View File

@ -0,0 +1,864 @@
From 95029b0ae49082d660330042c6c2becc9133124d Mon Sep 17 00:00:00 2001
From: liubo <liubo254@huawei.com>
Date: Thu, 3 Mar 2022 10:25:08 +0800
Subject: [PATCH 13/33] etmem: add code of testcase
add code of testcase for etmem scan function
add code of testcase for etmem threadpool function
add code of testcase for etmem threadtimer function
Signed-off-by: liubo <liubo254@huawei.com>
---
.../etmem_scan_ops_export_llt_test/CMakeLists.txt | 26 ++
.../etmem_scan_ops_export_llt.c | 279 +++++++++++++++++++++
.../etmem_threadpool_ops_llt_test/CMakeLists.txt | 26 ++
.../etmem_threadpool_ops_llt.c | 260 +++++++++++++++++++
etmem/test/etmem_timer_ops_llt_test/CMakeLists.txt | 26 ++
.../etmem_timer_ops_llt_test/etmem_timer_ops_llt.c | 183 ++++++++++++++
6 files changed, 800 insertions(+)
create mode 100644 etmem/test/etmem_scan_ops_export_llt_test/CMakeLists.txt
create mode 100644 etmem/test/etmem_scan_ops_export_llt_test/etmem_scan_ops_export_llt.c
create mode 100644 etmem/test/etmem_threadpool_ops_llt_test/CMakeLists.txt
create mode 100644 etmem/test/etmem_threadpool_ops_llt_test/etmem_threadpool_ops_llt.c
create mode 100644 etmem/test/etmem_timer_ops_llt_test/CMakeLists.txt
create mode 100644 etmem/test/etmem_timer_ops_llt_test/etmem_timer_ops_llt.c
diff --git a/etmem/test/etmem_scan_ops_export_llt_test/CMakeLists.txt b/etmem/test/etmem_scan_ops_export_llt_test/CMakeLists.txt
new file mode 100644
index 0000000..be68154
--- /dev/null
+++ b/etmem/test/etmem_scan_ops_export_llt_test/CMakeLists.txt
@@ -0,0 +1,26 @@
+# /******************************************************************************
+# * Copyright (c) Huawei Technologies Co., Ltd. 2019-2021. All rights reserved.
+# * etmem is licensed under the Mulan PSL v2.
+# * You can use this software according to the terms and conditions of the Mulan PSL v2.
+# * You may obtain a copy of Mulan PSL v2 at:
+# * http://license.coscl.org.cn/MulanPSL2
+# * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+# * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+# * PURPOSE.
+# * See the Mulan PSL v2 for more details.
+# * Author: shikemeng
+# * Create: 2021-11-30
+# * Description: CMakefileList for etmem_scan_ops_llt_test
+# ******************************************************************************/
+
+project(etmem)
+
+INCLUDE_DIRECTORIES(../../inc/etmem_inc)
+INCLUDE_DIRECTORIES(../../inc/etmemd_inc)
+INCLUDE_DIRECTORIES(${GLIB2_INCLUDE_DIRS})
+
+SET(EXE etmem_scan_ops_export_llt)
+
+add_executable(${EXE} etmem_scan_ops_export_llt.c)
+
+target_link_libraries(${EXE} cunit ${BUILD_DIR}/lib/libetmemd.so pthread dl rt libboundscheck numa ${GLIB2_LIBRARIES})
diff --git a/etmem/test/etmem_scan_ops_export_llt_test/etmem_scan_ops_export_llt.c b/etmem/test/etmem_scan_ops_export_llt_test/etmem_scan_ops_export_llt.c
new file mode 100644
index 0000000..e8e6098
--- /dev/null
+++ b/etmem/test/etmem_scan_ops_export_llt_test/etmem_scan_ops_export_llt.c
@@ -0,0 +1,279 @@
+/******************************************************************************
+ * Copyright (c) Huawei Technologies Co., Ltd. 2019-2021. All rights reserved.
+ * etmem is licensed under the Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ * http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+ * PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * Author: yangkunlin
+ * Create: 2021-11-30
+ * Description: test for the export scan library
+ ******************************************************************************/
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <CUnit/Basic.h>
+#include <CUnit/Automated.h>
+#include <CUnit/Console.h>
+
+#include "etmemd_scan_export.h"
+
+/* normal init and exit */
+static void test_etmem_exp_scan_001(void)
+{
+ /* for test of exit without init*/
+ etmemd_scan_exit();
+
+ CU_ASSERT_EQUAL(etmemd_scan_init(), 0);
+ etmemd_scan_exit();
+}
+
+static void test_etmem_exp_scan_002(void)
+{
+ /* for test of exit without init*/
+ etmemd_scan_exit();
+
+ CU_ASSERT_EQUAL(etmemd_scan_init(), 0);
+
+ /* init again before exit */
+ CU_ASSERT_NOT_EQUAL(etmemd_scan_init(), 0);
+ etmemd_scan_exit();
+}
+
+static void check_vmas(struct vmas *vmas)
+{
+ int i;
+ struct vma *curr_vma = NULL;
+
+ CU_ASSERT_NOT_EQUAL(vmas->vma_cnt, 0);
+
+ curr_vma = vmas->vma_list;
+ for (i = 0; i < vmas->vma_cnt; i++) {
+ CU_ASSERT_PTR_NOT_NULL(curr_vma);
+ curr_vma = curr_vma->next;
+ }
+}
+
+/* test invalid get_vmas */
+static void test_etmem_exp_scan_004(void)
+{
+ const char *pid = "1";
+ char *vmflags_array[10] = {"rd"};
+ int vmflag_num = 1;
+ int is_anon_only = false;
+ struct vmas *vmas = NULL;
+
+ CU_ASSERT_EQUAL(etmemd_scan_init(), 0);
+
+ /* non-exist pid */
+ vmas = etmemd_get_vmas("0", vmflags_array, vmflag_num, is_anon_only);
+ CU_ASSERT_PTR_NULL(vmas);
+
+ /* pid is NULL */
+ vmas = etmemd_get_vmas(NULL, vmflags_array, vmflag_num, is_anon_only);
+ CU_ASSERT_PTR_NULL(vmas);
+
+ /* pid contains invalid characters */
+ vmas = etmemd_get_vmas("1-", vmflags_array, vmflag_num, is_anon_only);
+ CU_ASSERT_PTR_NULL(vmas);
+
+ /* vmflags contains space */
+ vmflags_array[0] = "r ";
+ vmas = etmemd_get_vmas(pid, vmflags_array, vmflag_num, is_anon_only);
+ CU_ASSERT_PTR_NULL(vmas);
+
+ /* vmflags length is not 2 */
+ vmflags_array[0] = "rd ";
+ vmas = etmemd_get_vmas(pid, vmflags_array, vmflag_num, is_anon_only);
+ CU_ASSERT_PTR_NULL(vmas);
+
+ /* vmflags is NULL */
+ vmflags_array[0] = NULL;
+ vmas = etmemd_get_vmas(pid, vmflags_array, vmflag_num, is_anon_only);
+ CU_ASSERT_PTR_NULL(vmas);
+
+ /* test free is NULL */
+ vmas = NULL;
+ etmemd_free_vmas(vmas);
+
+ etmemd_scan_exit();
+}
+
+
+/* test valid get_vmas */
+static void test_etmem_exp_scan_003(void)
+{
+ const char *pid = "1";
+ char *vmflags_array[10] = {"rd"};
+ int vmflag_num = 1;
+ int is_anon_only = false;
+ struct vmas *vmas = NULL;
+ struct vma *curr_vma = NULL;
+ int i;
+
+ /* get vmas without init */
+ vmas = etmemd_get_vmas(pid, vmflags_array, vmflag_num, is_anon_only);
+ CU_ASSERT_PTR_NOT_NULL(vmas);
+ check_vmas(vmas);
+ etmemd_free_vmas(vmas);
+
+ /* get vmas with init */
+ CU_ASSERT_EQUAL(etmemd_scan_init(), 0);
+ vmas = etmemd_get_vmas(pid, vmflags_array, vmflag_num, is_anon_only);
+ CU_ASSERT_PTR_NOT_NULL(vmas);
+ check_vmas(vmas);
+ etmemd_free_vmas(vmas);
+ etmemd_scan_exit();
+}
+
+/* test invalid get_page_refs */
+static void test_etmem_exp_scan_006(void)
+{
+ const char *pid = "1";
+ char *vmflags_array[10] = {"rd"};
+ int vmflag_num = 1;
+ int is_anon_only = false;
+ struct vmas *vmas = NULL;
+ struct page_refs *page_refs = NULL;
+ int flags = SCAN_AS_HUGE | SCAN_IGN_HOST;
+
+ CU_ASSERT_EQUAL(etmemd_scan_init(), 0);
+
+ /* free null pointer */
+ etmemd_free_page_refs(page_refs);
+
+ /* vmas is NULL */
+ CU_ASSERT_EQUAL(etmemd_get_page_refs(vmas, pid, &page_refs, flags), -1);
+
+ /* vmas address range invalid*/
+ vmas = (struct vmas *)calloc(1, sizeof(struct vmas));
+ CU_ASSERT_PTR_NOT_NULL(vmas);
+ vmas->vma_cnt = 1;
+
+ struct vma *vma = (struct vma *)calloc(1, sizeof(struct vma));
+ CU_ASSERT_PTR_NOT_NULL(vma);
+ vma->start = 0x0ff;
+ vma->end = 0x000;
+ vma->next = NULL;
+ vmas->vma_list = vma;
+
+ CU_ASSERT_EQUAL(etmemd_get_page_refs(vmas, pid, &page_refs, flags), -1);
+ etmemd_free_vmas(vmas);
+
+ vmas = etmemd_get_vmas(pid, vmflags_array, vmflag_num, is_anon_only);
+ CU_ASSERT_PTR_NOT_NULL(vmas);
+ check_vmas(vmas);
+
+ /* pid not exist */
+ CU_ASSERT_EQUAL(etmemd_get_page_refs(vmas, "0", &page_refs, flags), -1);
+ CU_ASSERT_PTR_NULL(page_refs);
+
+ /* pid is NULL */
+ CU_ASSERT_EQUAL(etmemd_get_page_refs(vmas, NULL, &page_refs, flags), -1);
+ CU_ASSERT_PTR_NULL(page_refs);
+
+ /* pid contains invalid chars */
+ CU_ASSERT_EQUAL(etmemd_get_page_refs(vmas, "--", &page_refs, flags), -1);
+ CU_ASSERT_PTR_NULL(page_refs);
+
+ etmemd_free_page_refs(page_refs);
+ etmemd_free_vmas(vmas);
+ etmemd_scan_exit();
+}
+
+/* test valid get_page_refs */
+static void test_etmem_exp_scan_005(void)
+{
+ CU_ASSERT_EQUAL(etmemd_scan_init(), 0);
+
+ const char *pid = "1";
+ char *vmflags_array[10] = {"rd"};
+ int vmflag_num = 1;
+ int is_anon_only = false;
+ struct vmas *vmas = NULL;
+ struct page_refs *page_refs = NULL;
+ int flags = SCAN_AS_HUGE | SCAN_IGN_HOST;
+
+ vmas = etmemd_get_vmas(pid, vmflags_array, vmflag_num, is_anon_only);
+ CU_ASSERT_PTR_NOT_NULL(vmas);
+ check_vmas(vmas);
+
+ CU_ASSERT_EQUAL(etmemd_get_page_refs(vmas, pid, &page_refs, flags), 0);
+ CU_ASSERT_PTR_NOT_NULL(page_refs);
+
+ etmemd_scan_exit();
+
+ /* get_page_refs after exit */
+ CU_ASSERT_NOT_EQUAL(etmemd_get_page_refs(vmas, pid, &page_refs, flags), 0);
+
+ etmemd_free_page_refs(page_refs);
+ etmemd_free_vmas(vmas);
+}
+
+typedef enum {
+ CUNIT_SCREEN = 0,
+ CUNIT_XMLFILE,
+ CUNIT_CONSOLE
+} cu_run_mode;
+
+int main(int argc, const char **argv)
+{
+ CU_pSuite suite;
+ CU_pTest pTest;
+ unsigned int num_failures;
+ cu_run_mode cunit_mode = CUNIT_SCREEN;
+ int error_num;
+
+ if (argc > 1) {
+ cunit_mode = atoi(argv[1]);
+ }
+
+ if (CU_initialize_registry() != CUE_SUCCESS) {
+ return CU_get_error();
+ }
+
+ suite = CU_add_suite("etmem_scan_ops_exp", NULL, NULL);
+ if (suite == NULL) {
+ goto ERROR;
+ }
+
+ if (CU_ADD_TEST(suite, test_etmem_exp_scan_001) == NULL ||
+ CU_ADD_TEST(suite, test_etmem_exp_scan_002) == NULL ||
+ CU_ADD_TEST(suite, test_etmem_exp_scan_003) == NULL ||
+ CU_ADD_TEST(suite, test_etmem_exp_scan_004) == NULL ||
+ CU_ADD_TEST(suite, test_etmem_exp_scan_005) == NULL ||
+ CU_ADD_TEST(suite, test_etmem_exp_scan_006) == NULL) {
+ goto ERROR;
+ }
+
+ switch (cunit_mode) {
+ case CUNIT_SCREEN:
+ CU_basic_set_mode(CU_BRM_VERBOSE);
+ CU_basic_run_tests();
+ break;
+ case CUNIT_XMLFILE:
+ CU_set_output_filename("etmemd_scan.c");
+ CU_automated_run_tests();
+ break;
+ case CUNIT_CONSOLE:
+ CU_console_run_tests();
+ break;
+ default:
+ printf("not support cunit mode, only support: "
+ "0 for CUNIT_SCREEN, 1 for CUNIT_XMLFILE, 2 for CUNIT_CONSOLE\n");
+ goto ERROR;
+ }
+
+ num_failures = CU_get_number_of_failures();
+ CU_cleanup_registry();
+ return num_failures;
+
+ERROR:
+ error_num = CU_get_error();
+ CU_cleanup_registry();
+ return -error_num;
+}
diff --git a/etmem/test/etmem_threadpool_ops_llt_test/CMakeLists.txt b/etmem/test/etmem_threadpool_ops_llt_test/CMakeLists.txt
new file mode 100644
index 0000000..cb084cf
--- /dev/null
+++ b/etmem/test/etmem_threadpool_ops_llt_test/CMakeLists.txt
@@ -0,0 +1,26 @@
+# /******************************************************************************
+# * Copyright (c) Huawei Technologies Co., Ltd. 2019-2021. All rights reserved.
+# * etmem is licensed under the Mulan PSL v2.
+# * You can use this software according to the terms and conditions of the Mulan PSL v2.
+# * You may obtain a copy of Mulan PSL v2 at:
+# * http://license.coscl.org.cn/MulanPSL2
+# * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+# * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+# * PURPOSE.
+# * See the Mulan PSL v2 for more details.
+# * Author: liubo
+# * Create: 2021-11-30
+# * Description: CMakefileList for etmem_threadpool_ops_llt_test
+# ******************************************************************************/
+
+project(etmem)
+
+INCLUDE_DIRECTORIES(../../inc/etmem_inc)
+INCLUDE_DIRECTORIES(../../inc/etmemd_inc)
+INCLUDE_DIRECTORIES(${GLIB2_INCLUDE_DIRS})
+
+SET(EXE etmem_threadpool_ops_llt)
+
+add_executable(${EXE} etmem_threadpool_ops_llt.c)
+
+target_link_libraries(${EXE} cunit ${BUILD_DIR}/lib/libetmemd.so pthread dl rt libboundscheck numa ${GLIB2_LIBRARIES})
diff --git a/etmem/test/etmem_threadpool_ops_llt_test/etmem_threadpool_ops_llt.c b/etmem/test/etmem_threadpool_ops_llt_test/etmem_threadpool_ops_llt.c
new file mode 100644
index 0000000..9917954
--- /dev/null
+++ b/etmem/test/etmem_threadpool_ops_llt_test/etmem_threadpool_ops_llt.c
@@ -0,0 +1,260 @@
+/******************************************************************************
+ * Copyright (c) Huawei Technologies Co., Ltd. 2019-2021. All rights reserved.
+ * etmem is licensed under the Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ * http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+ * PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * Author: liubo
+ * Create: 2020-08-13
+ * Description: test for etmem threadpool operations
+ ******************************************************************************/
+#include <sys/file.h>
+#include <sys/sysinfo.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+#include <unistd.h>
+#include <limits.h>
+#include <glib.h>
+#include <pthread.h>
+
+#include <CUnit/Basic.h>
+#include <CUnit/Automated.h>
+#include <CUnit/Console.h>
+
+#include "etmemd_threadpool.h"
+#include "etmemd_pool_adapter.h"
+#include "etmemd_project.h"
+#include "etmemd_file.h"
+#include "etmemd_common.h"
+#include "etmemd_engine.h"
+#include "etmemd_slide.h"
+#include "etmemd_cslide.h"
+#include "securec.h"
+
+#define ADD_WORKER_NUM 100
+typedef void *(*add_worker_exector)(void *);
+
+static struct task_executor g_test_exec;
+static int g_task_exe_time = 0;
+static struct engine_ops g_test_eng_ops = {
+ .alloc_pid_params = NULL,
+ .free_pid_params = NULL,
+};
+
+static void get_threadpool_create_num(int num, int exp)
+{
+ thread_pool *pool = NULL;
+
+ pool = threadpool_create(num);
+ CU_ASSERT_PTR_NOT_NULL(pool);
+
+ CU_ASSERT_EQUAL(pool->max_thread_cap, exp);
+ threadpool_stop_and_destroy(&pool);
+}
+
+static void test_threadpool_create(void)
+{
+ int core = get_nprocs();
+
+ get_threadpool_create_num(1, 1);
+ get_threadpool_create_num(2, 2);
+ get_threadpool_create_num(2 * core, 2 * core);
+ get_threadpool_create_num(2 * core + 1, 2 * core + 1);
+
+ threadpool_notify(NULL);
+ threadpool_reset_status(NULL);
+}
+
+static void test_threadpool_delete(void)
+{
+ thread_pool *pool = NULL;
+ threadpool_stop_and_destroy(&pool);
+
+ pool = threadpool_create(1);
+ CU_ASSERT_PTR_NOT_NULL(pool);
+
+ threadpool_stop_and_destroy(&pool);
+ CU_ASSERT_PTR_NULL(pool);
+}
+
+static void *add_worker_fun(void *str)
+{
+ char *temp_str = str;
+ printf("str: %s \n", temp_str);
+ return NULL;
+}
+
+static unsigned int get_workerlist_num(const thread_pool *pool)
+{
+ unsigned int num = 0;
+ thread_worker *worker = pool->worker_list;
+
+ while (worker) {
+ num++;
+ worker = worker->next_node;
+ }
+
+ return num;
+}
+
+static void test_thpool_addwk_single(void)
+{
+ char *args = "for add worker test.\n";
+ thread_pool *pool = NULL;
+ add_worker_exector exector = add_worker_fun;
+
+ pool = threadpool_create(1);
+ CU_ASSERT_PTR_NOT_NULL(pool);
+
+ CU_ASSERT_EQUAL(threadpool_add_worker(pool, NULL, NULL), -1);
+ CU_ASSERT_EQUAL(threadpool_add_worker(pool, exector, NULL), -1);
+ CU_ASSERT_EQUAL(threadpool_add_worker(pool, NULL, args), -1);
+ CU_ASSERT_EQUAL(threadpool_add_worker(pool, exector, args), 0);
+
+ CU_ASSERT_PTR_NOT_NULL(pool->worker_list);
+ CU_ASSERT_EQUAL(get_workerlist_num(pool), 1);
+
+ threadpool_stop_and_destroy(&pool);
+ CU_ASSERT_PTR_NULL(pool);
+}
+
+static void test_thpool_addwk_mul(void)
+{
+ char *args = "for add worker test.\n";
+ thread_pool *pool = NULL;
+ int add_num;
+ add_worker_exector exector = add_worker_fun;
+
+ pool = threadpool_create(1);
+ CU_ASSERT_PTR_NOT_NULL(pool);
+
+ for (add_num = 0; add_num < ADD_WORKER_NUM; add_num++) {
+ CU_ASSERT_EQUAL(threadpool_add_worker(pool, exector, args), 0);
+ }
+
+ CU_ASSERT_PTR_NOT_NULL(pool->worker_list);
+ CU_ASSERT_EQUAL(__atomic_load_n(&pool->scheduing_size, __ATOMIC_SEQ_CST), ADD_WORKER_NUM);
+
+ threadpool_stop_and_destroy(&pool);
+ CU_ASSERT_PTR_NULL(pool);
+}
+
+static void init_thpool_objs(struct project *proj, struct engine *eng, struct task *tk)
+{
+ proj->interval = 1;
+ proj->start = true;
+ proj->name = "test_project";
+ eng->proj = proj;
+ eng->ops = &g_test_eng_ops;
+ tk->eng = eng;
+ tk->type = "pid";
+ tk->value = "1";
+ tk->max_threads = 10;
+}
+
+static void test_thpool_start_error(void)
+{
+ struct task tk;
+ struct engine eng;
+ struct project proj;
+
+ init_thpool_objs(&proj, &eng, &tk);
+
+ tk.max_threads = 0;
+ g_test_exec.tk = &tk;
+
+ CU_ASSERT_EQUAL(start_threadpool_work(&g_test_exec), -1);
+}
+
+static void *task_executor(void *arg)
+{
+ g_task_exe_time++;
+ return NULL;
+}
+
+static void test_thpool_start_stop(void)
+{
+ struct task tk = {0};
+ struct engine eng = {0};
+ struct project proj = {0};
+
+ init_thpool_objs(&proj, &eng, &tk);
+
+ g_test_exec.tk = &tk;
+ g_test_exec.func = task_executor;
+
+ CU_ASSERT_EQUAL(start_threadpool_work(&g_test_exec), 0);
+ /* wait threadpool to work */
+ sleep(2);
+ stop_and_delete_threadpool_work(&tk);
+}
+
+typedef enum {
+ CUNIT_SCREEN = 0,
+ CUNIT_XMLFILE,
+ CUNIT_CONSOLE
+} cu_run_mode;
+
+int main(int argc, const char **argv)
+{
+ CU_pSuite suite;
+ CU_pTest pTest;
+ unsigned int num_failures;
+ cu_run_mode cunit_mode = CUNIT_SCREEN;
+ int error_num;
+
+ if (argc > 1) {
+ cunit_mode = atoi(argv[1]);
+ }
+
+ if (CU_initialize_registry() != CUE_SUCCESS) {
+ return CU_get_error();
+ }
+
+ suite = CU_add_suite("etmem_threadpool_ops", NULL, NULL);
+ if (suite == NULL) {
+ goto ERROR;
+ }
+
+ if (CU_ADD_TEST(suite, test_threadpool_create) == NULL ||
+ CU_ADD_TEST(suite, test_threadpool_delete) == NULL ||
+ CU_ADD_TEST(suite, test_thpool_addwk_single) == NULL ||
+ CU_ADD_TEST(suite, test_thpool_addwk_mul) == NULL ||
+ CU_ADD_TEST(suite, test_thpool_start_stop) == NULL ||
+ CU_ADD_TEST(suite, test_thpool_start_error) == NULL) {
+ goto ERROR;
+ }
+
+ switch (cunit_mode) {
+ case CUNIT_SCREEN:
+ CU_basic_set_mode(CU_BRM_VERBOSE);
+ CU_basic_run_tests();
+ break;
+ case CUNIT_XMLFILE:
+ CU_set_output_filename("etmemd_threadpool.c");
+ CU_automated_run_tests();
+ break;
+ case CUNIT_CONSOLE:
+ CU_console_run_tests();
+ break;
+ default:
+ printf("not support cunit mode, only support: "
+ "0 for CUNIT_SCREEN, 1 for CUNIT_XMLFILE, 2 for CUNIT_CONSOLE\n");
+ goto ERROR;
+ }
+
+ num_failures = CU_get_number_of_failures();
+ CU_cleanup_registry();
+ return num_failures;
+
+ERROR:
+ error_num = CU_get_error();
+ CU_cleanup_registry();
+ return -error_num;
+}
diff --git a/etmem/test/etmem_timer_ops_llt_test/CMakeLists.txt b/etmem/test/etmem_timer_ops_llt_test/CMakeLists.txt
new file mode 100644
index 0000000..76aa48e
--- /dev/null
+++ b/etmem/test/etmem_timer_ops_llt_test/CMakeLists.txt
@@ -0,0 +1,26 @@
+# /******************************************************************************
+# * Copyright (c) Huawei Technologies Co., Ltd. 2019-2021. All rights reserved.
+# * etmem is licensed under the Mulan PSL v2.
+# * You can use this software according to the terms and conditions of the Mulan PSL v2.
+# * You may obtain a copy of Mulan PSL v2 at:
+# * http://license.coscl.org.cn/MulanPSL2
+# * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+# * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+# * PURPOSE.
+# * See the Mulan PSL v2 for more details.
+# * Author: liubo
+# * Create: 2021-11-30
+# * Description: CMakefileList for etmem_timer_ops_llt_test
+# ******************************************************************************/
+
+project(etmem)
+
+INCLUDE_DIRECTORIES(../../inc/etmem_inc)
+INCLUDE_DIRECTORIES(../../inc/etmemd_inc)
+INCLUDE_DIRECTORIES(${GLIB2_INCLUDE_DIRS})
+
+SET(EXE etmem_timer_ops_llt)
+
+add_executable(${EXE} etmem_timer_ops_llt.c)
+
+target_link_libraries(${EXE} cunit ${BUILD_DIR}/lib/libetmemd.so pthread dl rt libboundscheck numa ${GLIB2_LIBRARIES})
diff --git a/etmem/test/etmem_timer_ops_llt_test/etmem_timer_ops_llt.c b/etmem/test/etmem_timer_ops_llt_test/etmem_timer_ops_llt.c
new file mode 100644
index 0000000..c97cdf9
--- /dev/null
+++ b/etmem/test/etmem_timer_ops_llt_test/etmem_timer_ops_llt.c
@@ -0,0 +1,183 @@
+/******************************************************************************
+ * Copyright (c) Huawei Technologies Co., Ltd. 2019-2021. All rights reserved.
+ * etmem is licensed under the Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ * http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+ * PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * Author: liubo
+ * Create: 2020-08-13
+ * Description: test for etmem timer operations
+ ******************************************************************************/
+#include <sys/file.h>
+#include <sys/sysinfo.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+#include <unistd.h>
+
+#include <CUnit/Basic.h>
+#include <CUnit/Automated.h>
+#include <CUnit/Console.h>
+
+#include "etmemd_threadtimer.h"
+
+static int g_timer_exec_time = 0;
+
+typedef void *(*timer_exector)(void *);
+
+static void get_timer_expired_time(int time, int exp)
+{
+ timer_thread *timer = NULL;
+
+ timer = thread_timer_create(time);
+ CU_ASSERT_PTR_NOT_NULL(timer);
+
+ CU_ASSERT_EQUAL(timer->expired_time, exp);
+ thread_timer_destroy(&timer);
+}
+
+static void test_timer_create_delete(void)
+{
+ timer_thread *timer = NULL;
+ thread_timer_destroy(&timer);
+
+ get_timer_expired_time(1, 1);
+ get_timer_expired_time(2, 2);
+ get_timer_expired_time(50, 50);
+ get_timer_expired_time(1199, 1199);
+ get_timer_expired_time(1201, 1201);
+}
+
+static void *threadtimer_exector(void *str)
+{
+ char *temp_str = str;
+ printf("threadtimer_exector: %s\n", temp_str);
+ g_timer_exec_time++;
+ return NULL;
+}
+
+static void test_timer_start_error(void)
+{
+ char *timer_args = "for timer start test.\n";
+ timer_exector exector = threadtimer_exector;
+ timer_thread *timer = NULL;
+
+ timer = thread_timer_create(60);
+ CU_ASSERT_PTR_NOT_NULL(timer);
+
+ CU_ASSERT_EQUAL(thread_timer_start(NULL, NULL, NULL), -1);
+ CU_ASSERT_EQUAL(thread_timer_start(timer, NULL, NULL), -1);
+ CU_ASSERT_EQUAL(thread_timer_start(timer, exector, NULL), -1);
+ CU_ASSERT_EQUAL(thread_timer_start(timer, NULL, timer_args), -1);
+ CU_ASSERT_EQUAL(thread_timer_start(timer, exector, timer_args), 0);
+ CU_ASSERT_FALSE(timer->down);
+ CU_ASSERT_EQUAL(thread_timer_start(timer, exector, timer_args), 0);
+
+ thread_timer_destroy(&timer);
+ thread_timer_stop(timer);
+}
+
+static void test_timer_start_ok(void)
+{
+ char *timer_args = "for timer start test.\n";
+ timer_exector exector = threadtimer_exector;
+ timer_thread *timer = NULL;
+
+ timer = thread_timer_create(1);
+ CU_ASSERT_PTR_NOT_NULL(timer);
+
+ CU_ASSERT_EQUAL(thread_timer_start(timer, exector, timer_args), 0);
+ CU_ASSERT_FALSE(timer->down);
+
+ sleep(2);
+ CU_ASSERT_NOT_EQUAL(g_timer_exec_time, 0);
+
+ thread_timer_stop(timer);
+ thread_timer_destroy(&timer);
+}
+
+static void test_timer_stop(void)
+{
+ char *timer_args = "for timer start test.\n";
+ timer_exector exector = threadtimer_exector;
+ timer_thread *timer = NULL;
+
+ thread_timer_stop(timer);
+
+ timer = thread_timer_create(60);
+ CU_ASSERT_PTR_NOT_NULL(timer);
+
+ CU_ASSERT_EQUAL(thread_timer_start(timer, exector, timer_args), 0);
+ CU_ASSERT_FALSE(timer->down);
+
+ thread_timer_stop(timer);
+ CU_ASSERT_TRUE(timer->down);
+ thread_timer_destroy(&timer);
+}
+
+typedef enum {
+ CUNIT_SCREEN = 0,
+ CUNIT_XMLFILE,
+ CUNIT_CONSOLE
+} cu_run_mode;
+
+int main(int argc, const char **argv)
+{
+ CU_pSuite suite;
+ CU_pTest pTest;
+ unsigned int num_failures;
+ cu_run_mode cunit_mode = CUNIT_SCREEN;
+ int error_num;
+
+ if (argc > 1) {
+ cunit_mode = atoi(argv[1]);
+ }
+
+ if (CU_initialize_registry() != CUE_SUCCESS) {
+ return CU_get_error();
+ }
+
+ suite = CU_add_suite("etmem_timer_ops", NULL, NULL);
+ if (suite == NULL) {
+ goto ERROR;
+ }
+
+ if (CU_ADD_TEST(suite, test_timer_create_delete) == NULL ||
+ CU_ADD_TEST(suite, test_timer_start_error) == NULL ||
+ CU_ADD_TEST(suite, test_timer_start_ok) == NULL ||
+ CU_ADD_TEST(suite, test_timer_stop) == NULL) {
+ goto ERROR;
+ }
+
+ switch (cunit_mode) {
+ case CUNIT_SCREEN:
+ CU_basic_set_mode(CU_BRM_VERBOSE);
+ CU_basic_run_tests();
+ break;
+ case CUNIT_XMLFILE:
+ CU_set_output_filename("etmemd_threadtimer.c");
+ CU_automated_run_tests();
+ break;
+ case CUNIT_CONSOLE:
+ CU_console_run_tests();
+ break;
+ default:
+ printf("not support cunit mode, only support: "
+ "0 for CUNIT_SCREEN, 1 for CUNIT_XMLFILE, 2 for CUNIT_CONSOLE\n");
+ goto ERROR;
+ }
+
+ num_failures = CU_get_number_of_failures();
+ CU_cleanup_registry();
+ return num_failures;
+
+ERROR:
+ error_num = CU_get_error();
+ CU_cleanup_registry();
+ return -error_num;
+}
--
1.8.3.1

1202
0064-etmem-add-code-of-testcase.patch Normal file
View File

File diff suppressed because it is too large Load Diff

682
0065-etmem-add-code-of-testcase.patch Normal file
View File

@ -0,0 +1,682 @@
From 9018988c20ce1ee49d2d4458d85b72993ee39283 Mon Sep 17 00:00:00 2001
From: liubo <liubo254@huawei.com>
Date: Mon, 24 Jan 2022 03:02:41 +0800
Subject: [PATCH 15/33] etmem: add code of testcase
add code of testcase for etmem migrate functions
add testcase to etmem project function
Signed-off-by: liubo <liubo254@huawei.com>
---
etmem/test/common/test_common.c | 33 ++-
etmem/test/common/test_common.h | 72 ++++---
etmem/test/etmem_migrate_ops_llt/CMakeLists.txt | 27 +++
.../etmem_migrate_ops_llt/etmem_migrate_ops_llt.c | 226 +++++++++++++++++++++
.../etmem_project_ops_llt.c | 161 ++++++++++++++-
.../etmem_scan_ops_llt_test/etmem_scan_ops_llt.c | 4 +-
6 files changed, 484 insertions(+), 39 deletions(-)
create mode 100644 etmem/test/etmem_migrate_ops_llt/CMakeLists.txt
create mode 100644 etmem/test/etmem_migrate_ops_llt/etmem_migrate_ops_llt.c
diff --git a/etmem/test/common/test_common.c b/etmem/test/common/test_common.c
index 4551177..4bd3fc3 100644
--- a/etmem/test/common/test_common.c
+++ b/etmem/test/common/test_common.c
@@ -63,6 +63,18 @@ void construct_proj_file(struct proj_test_param *param)
if (param->sleep != NULL) {
CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_SLEEP, param->sleep), -1);
}
+ if (param->sysmem_threshold != NULL) {
+ CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_SYSMEM_THRESHOLD,
+ param->sysmem_threshold), -1);
+ }
+ if (param->swapcache_high_wmark != NULL) {
+ CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_SWAPCACHE_HIGH_WMARK,
+ param->swapcache_high_wmark), -1);
+ }
+ if (param->swapcache_low_wmark != NULL) {
+ CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_SWAPCACHE_LOW_WMARK,
+ param->swapcache_low_wmark), -1);
+ }
fclose(file);
}
@@ -83,12 +95,15 @@ void init_proj_param(struct proj_test_param *param)
param->sleep = "1";
param->interval = "1";
param->loop = "1";
+ param->sysmem_threshold = NULL;
+ param->swapcache_high_wmark = NULL;
+ param->swapcache_low_wmark = NULL;
param->file_name = TMP_PROJ_CONFIG;
param->proj_name = DEFAULT_PROJ;
param->expt = OPT_SUCCESS;
}
-void do_add_proj_test(struct proj_test_param * param)
+void do_add_proj_test(struct proj_test_param *param)
{
GKeyFile *config = NULL;
@@ -155,16 +170,16 @@ void construct_task_file(struct task_test_param *param)
CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_NAME, param->name), -1);
}
if (param->proj != NULL) {
- CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_PROJ, param->name), -1);
+ CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_PROJ, param->proj), -1);
}
if (param->eng != NULL) {
- CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_ENG, param->name), -1);
+ CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_ENG, param->eng), -1);
}
if (param->type != NULL) {
- CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_TYPE, param->name), -1);
+ CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_TYPE, param->type), -1);
}
if (param->value != NULL) {
- CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_VALUE, param->name), -1);
+ CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_VALUE, param->value), -1);
}
fclose(file);
}
@@ -174,6 +189,8 @@ void init_slide_task(struct slide_task_test_param *param)
init_task_param(&param->task_param, "slide");
param->max_threads = "1";
param->T = "1";
+ param->swap_flag = NULL;
+ param->swap_threshold = NULL;
}
void add_slide_task(struct slide_task_test_param *param)
@@ -189,6 +206,12 @@ void add_slide_task(struct slide_task_test_param *param)
if (param->T != NULL) {
CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_T, param->T), -1);
}
+ if (param->swap_flag != NULL) {
+ CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_SWAP_FLAG, param->swap_flag), -1);
+ }
+ if (param->swap_threshold != NULL) {
+ CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_SWAP_THRESHOLD, param->swap_threshold), -1);
+ }
fclose(file);
}
diff --git a/etmem/test/common/test_common.h b/etmem/test/common/test_common.h
index 009c458..1ba20c7 100644
--- a/etmem/test/common/test_common.h
+++ b/etmem/test/common/test_common.h
@@ -20,43 +20,51 @@
#include "etmemd_project.h"
-#define CONFIG_NAME "name=%s\n"
-#define CONFIG_INTERVAL "interval=%s\n"
-#define CONFIG_LOOP "loop=%s\n"
-#define CONFIG_SLEEP "sleep=%s\n"
-#define TMP_PROJ_CONFIG "proj_tmp.config"
-#define DEFAULT_PROJ "default_proj"
-
-#define CONFIG_PROJ "project=%s\n"
-#define TMP_ENG_CONFIG "eng_tmp.config"
-
-#define CONFIG_ENG "engine=%s\n"
-#define CONFIG_TYPE "type=%s\n"
-#define CONFIG_VALUE "value=%s\n"
-#define TMP_TASK_CONFIG "task_tmp.config"
-#define DEFAULT_TASK "default_task"
-
-#define CONFIG_MAX_THREADS "max_threads=%s\n"
-#define CONFIG_T "T=%s\n"
-
-#define CONFIG_NODE_PAIR "node_pair=%s\n"
-#define CONFIG_THRESH "hot_threshold=%s\n"
-#define CONFIG_QUOTA "node_mig_quota=%s\n"
-#define CONFIG_RESV "node_hot_reserve=%s\n"
-
-#define CONFIG_VM_FLAGS "vm_flags=%s\n"
-#define CONFIG_ANON_ONLY "anon_only=%s\n"
-#define CONFIG_IGN_HOST "igno_host=%s\n"
-
-#define ONE_NODE_PAIR 2
-#define TWO_NODE_PAIR 4
-#define THREE_NODE_PAIR 5
+#define CONFIG_NAME "name=%s\n"
+#define CONFIG_INTERVAL "interval=%s\n"
+#define CONFIG_LOOP "loop=%s\n"
+#define CONFIG_SLEEP "sleep=%s\n"
+#define CONFIG_SYSMEM_THRESHOLD "sysmem_threshold=%s\n"
+#define CONFIG_SWAPCACHE_HIGH_WMARK "swapcache_high_wmark=%s\n"
+#define CONFIG_SWAPCACHE_LOW_WMARK "swapcache_low_wmark=%s\n"
+#define TMP_PROJ_CONFIG "proj_tmp.config"
+#define DEFAULT_PROJ "default_proj"
+
+#define CONFIG_PROJ "project=%s\n"
+#define TMP_ENG_CONFIG "eng_tmp.config"
+
+#define CONFIG_ENG "engine=%s\n"
+#define CONFIG_TYPE "type=%s\n"
+#define CONFIG_VALUE "value=%s\n"
+#define TMP_TASK_CONFIG "task_tmp.config"
+#define DEFAULT_TASK "default_task"
+
+#define CONFIG_MAX_THREADS "max_threads=%s\n"
+#define CONFIG_T "T=%s\n"
+#define CONFIG_SWAP_FLAG "swap_flag=%s\n"
+#define CONFIG_SWAP_THRESHOLD "swap_threshold=%s\n"
+
+#define CONFIG_NODE_PAIR "node_pair=%s\n"
+#define CONFIG_THRESH "hot_threshold=%s\n"
+#define CONFIG_QUOTA "node_mig_quota=%s\n"
+#define CONFIG_RESV "node_hot_reserve=%s\n"
+
+#define CONFIG_VM_FLAGS "vm_flags=%s\n"
+#define CONFIG_ANON_ONLY "anon_only=%s\n"
+#define CONFIG_IGN_HOST "ign_host=%s\n"
+
+#define ONE_NODE_PAIR 2
+#define TWO_NODE_PAIR 4
+#define THREE_NODE_PAIR 6
struct proj_test_param {
const char *sleep;
const char *interval;
const char *loop;
+ const char *sysmem_threshold;
+ const char *swapcache_high_wmark;
+ const char *swapcache_low_wmark;
const char *proj_name;
const char *file_name;
enum opt_result expt;
@@ -81,6 +89,8 @@ struct slide_task_test_param {
struct task_test_param task_param;
const char *max_threads;
const char *T;
+ const char *swap_flag;
+ const char *swap_threshold;
};
struct cslide_eng_test_param {
diff --git a/etmem/test/etmem_migrate_ops_llt/CMakeLists.txt b/etmem/test/etmem_migrate_ops_llt/CMakeLists.txt
new file mode 100644
index 0000000..a9487af
--- /dev/null
+++ b/etmem/test/etmem_migrate_ops_llt/CMakeLists.txt
@@ -0,0 +1,27 @@
+# /******************************************************************************
+# * Copyright (c) Huawei Technologies Co., Ltd. 2019-2021. All rights reserved.
+# * etmem is licensed under the Mulan PSL v2.
+# * You can use this software according to the terms and conditions of the Mulan PSL v2.
+# * You may obtain a copy of Mulan PSL v2 at:
+# * http://license.coscl.org.cn/MulanPSL2
+# * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+# * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+# * PURPOSE.
+# * See the Mulan PSL v2 for more details.
+# * Author: liubo
+# * Create: 2021-12-10
+# * Description: CMakefileList for etmem_migrate_ops_llt to compile
+# ******************************************************************************/
+
+project(etmem)
+
+INCLUDE_DIRECTORIES(../../inc/etmem_inc)
+INCLUDE_DIRECTORIES(../../inc/etmemd_inc)
+INCLUDE_DIRECTORIES(${GLIB2_INCLUDE_DIRS})
+
+SET(EXE etmem_migrate_ops_llt)
+
+add_executable(${EXE} etmem_migrate_ops_llt.c)
+
+set_target_properties(${EXE} PROPERTIES LINK_FLAGS "-Wl,--wrap,get_mem_from_proc_file")
+target_link_libraries(${EXE} cunit ${BUILD_DIR}/lib/libetmemd.so pthread dl rt boundscheck numa ${GLIB2_LIBRARIES})
diff --git a/etmem/test/etmem_migrate_ops_llt/etmem_migrate_ops_llt.c b/etmem/test/etmem_migrate_ops_llt/etmem_migrate_ops_llt.c
new file mode 100644
index 0000000..2758680
--- /dev/null
+++ b/etmem/test/etmem_migrate_ops_llt/etmem_migrate_ops_llt.c
@@ -0,0 +1,226 @@
+/******************************************************************************
+ * Copyright (c) Huawei Technologies Co., Ltd. 2019-2021. All rights reserved.
+ * etmem is licensed under the Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ * http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+ * PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * Author: liubo
+ * Create: 2021-08-14
+ * Description: This is a source file of the unit test for log functions in etmem.
+ ******************************************************************************/
+
+#include <sys/file.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "etmemd.h"
+#include "etmemd_migrate.h"
+#include "etmemd_scan.h"
+#include "etmemd_project_exp.h"
+#include "etmemd_engine_exp.h"
+#include "etmemd_task_exp.h"
+#include "etmemd_task.h"
+
+#include <CUnit/Basic.h>
+#include <CUnit/Automated.h>
+#include <CUnit/Console.h>
+
+#define WATER_LINE_TEMP 2
+
+/* Function replacement used for mock test. This function is used only in dt. */
+int get_mem_from_proc_file(const char *pid, const char *file_name,
+ unsigned long *data, const char *cmpstr)
+{
+ *data = 100;
+ return 0;
+}
+
+void init_task_pid_param(struct task_pid *param)
+{
+ param->pid = 1;
+ param->rt_swapin_rate = 0.0;
+ param->params = NULL;
+ param->next = NULL;
+}
+
+static struct memory_grade *get_memory_grade(void)
+{
+ struct memory_grade *memory_grade = NULL;
+ struct vmas *vmas = NULL;
+ struct page_refs *page_refs = NULL;
+ const char *pid = "1";
+
+ init_g_page_size();
+ vmas = get_vmas(pid);
+ CU_ASSERT_PTR_NOT_NULL(vmas);
+ CU_ASSERT_EQUAL(get_page_refs(vmas, pid, &page_refs, NULL, NULL), 0);
+ free(vmas);
+ vmas = NULL;
+
+ memory_grade = (struct memory_grade *)calloc(1, sizeof(struct memory_grade));
+ CU_ASSERT_PTR_NOT_NULL(memory_grade);
+
+ while (page_refs != NULL)
+ {
+ if ((page_refs)->count >= WATER_LINE_TEMP) {
+ page_refs = add_page_refs_into_memory_grade(page_refs, &memory_grade->hot_pages);
+ continue;
+ }
+ page_refs = add_page_refs_into_memory_grade(page_refs, &memory_grade->cold_pages);
+ }
+
+ return memory_grade;
+}
+
+static void test_etmem_migrate_error(void)
+{
+ struct memory_grade *memory_grade = NULL;
+
+ memory_grade = (struct memory_grade *)calloc(1, sizeof(struct memory_grade));
+ CU_ASSERT_PTR_NOT_NULL(memory_grade);
+
+ CU_ASSERT_EQUAL(etmemd_grade_migrate("", memory_grade), 0);
+ CU_ASSERT_EQUAL(etmemd_grade_migrate("no123", memory_grade), 0);
+
+ free(memory_grade);
+
+ memory_grade = get_memory_grade();
+ CU_ASSERT_PTR_NOT_NULL(memory_grade);
+ CU_ASSERT_EQUAL(etmemd_grade_migrate("", memory_grade), -1);
+ CU_ASSERT_EQUAL(etmemd_grade_migrate("no123", memory_grade), -1);
+
+ clean_memory_grade_unexpected(&memory_grade);
+ CU_ASSERT_PTR_NULL(memory_grade);
+}
+
+static void test_etmem_migrate_ok(void)
+{
+ struct memory_grade *memory_grade = NULL;
+
+ memory_grade = get_memory_grade();
+ CU_ASSERT_PTR_NOT_NULL(memory_grade);
+ CU_ASSERT_EQUAL(etmemd_grade_migrate("1", memory_grade), -1);
+
+ clean_memory_grade_unexpected(&memory_grade);
+ CU_ASSERT_PTR_NULL(memory_grade);
+}
+
+static void test_etmemd_reclaim_swapcache_error(void)
+{
+ struct project proj = {0};
+ struct engine eng = {0};
+ struct task tk = {0};
+ struct task_pid tk_pid = {0};
+
+ proj.swapcache_high_wmark = 5;
+ proj.swapcache_low_wmark = 3;
+ tk_pid.tk = &tk;
+ tk.eng = &eng;
+ eng.proj = &proj;
+
+ CU_ASSERT_EQUAL(etmemd_reclaim_swapcache(NULL), -1);
+
+ init_task_pid_param(&tk_pid);
+ tk_pid.pid = 0;
+ proj.wmark_set = false;
+ CU_ASSERT_EQUAL(etmemd_reclaim_swapcache(&tk_pid), -1);
+
+ tk_pid.pid = 0;
+ proj.wmark_set = true;
+ CU_ASSERT_EQUAL(etmemd_reclaim_swapcache(&tk_pid), -1);
+}
+
+static void test_etmemd_reclaim_swapcache_ok(void)
+{
+ struct project proj = {0};
+ struct engine eng = {0};
+ struct task tk = {0};
+ struct task_pid tk_pid = {0};
+
+ tk_pid.tk = &tk;
+ tk.eng = &eng;
+ eng.proj = &proj;
+
+ init_task_pid_param(&tk_pid);
+ proj.swapcache_high_wmark = -1;
+ proj.swapcache_low_wmark = -1;
+ CU_ASSERT_EQUAL(etmemd_reclaim_swapcache(&tk_pid), 0);
+
+ proj.swapcache_high_wmark = 100;
+ proj.swapcache_low_wmark = 3;
+ CU_ASSERT_EQUAL(etmemd_reclaim_swapcache(&tk_pid), 0);
+
+ init_task_pid_param(&tk_pid);
+ proj.swapcache_high_wmark = 5;
+ proj.swapcache_low_wmark = 3;
+ proj.wmark_set = false;
+ CU_ASSERT_EQUAL(etmemd_reclaim_swapcache(&tk_pid), 0);
+}
+
+typedef enum {
+ CUNIT_SCREEN = 0,
+ CUNIT_XMLFILE,
+ CUNIT_CONSOLE
+} cu_run_mode;
+
+int main(int argc, const char **argv)
+{
+ CU_pSuite suite;
+ CU_pTest pTest;
+ unsigned int num_failures;
+ cu_run_mode cunit_mode = CUNIT_SCREEN;
+ int error_num;
+
+ if (argc > 1) {
+ cunit_mode = atoi(argv[1]);
+ }
+
+ if (CU_initialize_registry() != CUE_SUCCESS) {
+ return -CU_get_error();
+ }
+
+ suite = CU_add_suite("etmem_migrate_ops", NULL, NULL);
+ if (suite == NULL) {
+ goto ERROR;
+ }
+
+ if (CU_ADD_TEST(suite, test_etmem_migrate_error) == NULL ||
+ CU_ADD_TEST(suite, test_etmem_migrate_ok) == NULL ||
+ CU_ADD_TEST(suite, test_etmemd_reclaim_swapcache_error) == NULL ||
+ CU_ADD_TEST(suite, test_etmemd_reclaim_swapcache_ok) == NULL) {
+ printf("CU_ADD_TEST fail. \n");
+ goto ERROR;
+ }
+
+ switch (cunit_mode) {
+ case CUNIT_SCREEN:
+ CU_basic_set_mode(CU_BRM_VERBOSE);
+ CU_basic_run_tests();
+ break;
+ case CUNIT_XMLFILE:
+ CU_set_output_filename("etmemd_migrate.c");
+ CU_automated_run_tests();
+ break;
+ case CUNIT_CONSOLE:
+ CU_console_run_tests();
+ break;
+ default:
+ printf("not support cunit mode, only support: "
+ "0 for CUNIT_SCREEN, 1 for CUNIT_XMLFILE, 2 for CUNIT_CONSOLE\n");
+ goto ERROR;
+ }
+
+ num_failures = CU_get_number_of_failures();
+ CU_cleanup_registry();
+ return num_failures;
+
+ERROR:
+ error_num = CU_get_error();
+ CU_cleanup_registry();
+ return -error_num;
+}
diff --git a/etmem/test/etmem_project_ops_llt_test/etmem_project_ops_llt.c b/etmem/test/etmem_project_ops_llt_test/etmem_project_ops_llt.c
index a01e8e8..65c1fc6 100644
--- a/etmem/test/etmem_project_ops_llt_test/etmem_project_ops_llt.c
+++ b/etmem/test/etmem_project_ops_llt_test/etmem_project_ops_llt.c
@@ -117,6 +117,161 @@ static void etmem_pro_add_interval(void)
destroy_proj_config(config);
}
+static void etmem_pro_add_sysmem_threshold_error(void)
+{
+ struct proj_test_param param;
+ GKeyFile *config = NULL;
+
+ init_proj_param(&param);
+
+ param.sysmem_threshold = "101";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_INVAL);
+ destroy_proj_config(config);
+
+ param.sysmem_threshold = "abc";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_INVAL);
+ destroy_proj_config(config);
+
+ param.sysmem_threshold = "a10b";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_INVAL);
+ destroy_proj_config(config);
+
+ param.sysmem_threshold = "10a";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_INVAL);
+ destroy_proj_config(config);
+
+ param.sysmem_threshold = "-1";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_INVAL);
+ destroy_proj_config(config);
+}
+
+static void etmem_pro_add_sysmem_threshold_ok(void)
+{
+ struct proj_test_param param;
+ GKeyFile *config = NULL;
+
+ init_proj_param(&param);
+
+ param.sysmem_threshold = "0";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_SUCCESS);
+ CU_ASSERT_EQUAL(etmemd_project_remove(config), OPT_SUCCESS);
+ destroy_proj_config(config);
+
+ param.sysmem_threshold = "1";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_SUCCESS);
+ CU_ASSERT_EQUAL(etmemd_project_remove(config), OPT_SUCCESS);
+ destroy_proj_config(config);
+
+ param.sysmem_threshold = "2";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_SUCCESS);
+ CU_ASSERT_EQUAL(etmemd_project_remove(config), OPT_SUCCESS);
+ destroy_proj_config(config);
+
+ param.sysmem_threshold = "99";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_SUCCESS);
+ CU_ASSERT_EQUAL(etmemd_project_remove(config), OPT_SUCCESS);
+ destroy_proj_config(config);
+
+ param.sysmem_threshold = "100";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_SUCCESS);
+ CU_ASSERT_EQUAL(etmemd_project_remove(config), OPT_SUCCESS);
+ destroy_proj_config(config);
+}
+
+static void etmem_pro_add_swapcache_mark_error(void)
+{
+ struct proj_test_param param;
+ GKeyFile *config = NULL;
+
+ init_proj_param(&param);
+
+ param.swapcache_high_wmark = "-1";
+ param.swapcache_low_wmark = "-1";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_INVAL);
+ destroy_proj_config(config);
+
+ param.swapcache_high_wmark = "1";
+ param.swapcache_low_wmark = "-1";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_INVAL);
+ destroy_proj_config(config);
+
+ param.swapcache_high_wmark = "-1";
+ param.swapcache_low_wmark = "1";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_INVAL);
+ destroy_proj_config(config);
+
+ param.swapcache_high_wmark = "1";
+ param.swapcache_low_wmark = "2";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_INVAL);
+ destroy_proj_config(config);
+
+ param.swapcache_high_wmark = "101";
+ param.swapcache_low_wmark = "100";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_INVAL);
+ destroy_proj_config(config);
+
+ param.swapcache_high_wmark = "100";
+ param.swapcache_low_wmark = "101";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_INVAL);
+ destroy_proj_config(config);
+
+ param.swapcache_high_wmark = "101";
+ param.swapcache_low_wmark = "101";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_INVAL);
+ destroy_proj_config(config);
+
+ param.swapcache_high_wmark = "5";
+ param.swapcache_low_wmark = NULL;
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_INVAL);
+ destroy_proj_config(config);
+
+ param.swapcache_high_wmark = NULL;
+ param.swapcache_low_wmark = "5";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_INVAL);
+ destroy_proj_config(config);
+}
+
+static void etmem_pro_add_swapcache_mark_ok(void)
+{
+ struct proj_test_param param;
+ GKeyFile *config = NULL;
+
+ init_proj_param(&param);
+
+ param.swapcache_high_wmark = "2";
+ param.swapcache_low_wmark = "1";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_SUCCESS);
+ CU_ASSERT_EQUAL(etmemd_project_remove(config), OPT_SUCCESS);
+ destroy_proj_config(config);
+
+ param.swapcache_high_wmark = "100";
+ param.swapcache_low_wmark = "99";
+ config = construct_proj_config(&param);
+ CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_SUCCESS);
+ CU_ASSERT_EQUAL(etmemd_project_remove(config), OPT_SUCCESS);
+ destroy_proj_config(config);
+}
+
static void etmem_pro_add_loop(void)
{
struct proj_test_param param;
@@ -231,6 +386,8 @@ void test_etmem_prj_add_error(void)
etmem_pro_add_loop();
etmem_pro_add_sleep();
etmem_pro_lack_loop();
+ etmem_pro_add_sysmem_threshold_error();
+ etmem_pro_add_swapcache_mark_error();
}
void test_etmem_prj_del_error(void)
@@ -256,6 +413,8 @@ static void add_project_once(void)
struct proj_test_param param;
GKeyFile *config = NULL;
+ etmem_pro_add_sysmem_threshold_ok();
+ etmem_pro_add_swapcache_mark_ok();
init_proj_param(&param);
CU_ASSERT_EQUAL(etmemd_project_show(NULL, 0), OPT_PRO_NOEXIST);
@@ -348,7 +507,7 @@ void test_etmem_mig_stop_error(void)
CU_ASSERT_EQUAL(etmemd_migrate_stop(""), OPT_PRO_NOEXIST);
CU_ASSERT_EQUAL(etmemd_migrate_stop("ETMEM"), OPT_PRO_NOEXIST);
CU_ASSERT_EQUAL(etmemd_migrate_stop("ET^$%*MEM"), OPT_PRO_NOEXIST);
-
+
param.proj_name = "add_for_migrate_stop_test";
do_add_proj_test(&param);
diff --git a/etmem/test/etmem_scan_ops_llt_test/etmem_scan_ops_llt.c b/etmem/test/etmem_scan_ops_llt_test/etmem_scan_ops_llt.c
index 0cd2ecc..84fcf69 100644
--- a/etmem/test/etmem_scan_ops_llt_test/etmem_scan_ops_llt.c
+++ b/etmem/test/etmem_scan_ops_llt_test/etmem_scan_ops_llt.c
@@ -243,7 +243,7 @@ static void test_get_page_refs_valid()
unsigned long use_rss;
- CU_ASSERT_EQUAL(get_page_refs(vmas, pid, &page_refs, &use_rss, 0), 0);
+ CU_ASSERT_EQUAL(get_page_refs(vmas, pid, &page_refs, &use_rss, NULL), 0);
CU_ASSERT_PTR_NOT_NULL(page_refs);
CU_ASSERT_NOT_EQUAL(use_rss, 0);
@@ -309,7 +309,7 @@ static void test_add_pg_to_mem_grade()
CU_ASSERT_EQUAL(etmemd_scan_init(), 0);
vma = get_vmas(pid);
- CU_ASSERT_EQUAL(get_page_refs(vma, pid, &page_refs, NULL, 0), 0);
+ CU_ASSERT_EQUAL(get_page_refs(vma, pid, &page_refs, NULL, NULL), 0);
page_refs = add_page_refs_into_memory_grade(page_refs, &list);
CU_ASSERT_PTR_NOT_NULL(page_refs);
CU_ASSERT_PTR_NOT_NULL(list);
--
1.8.3.1

415
0066-etmem-add-sysmem_threshold-and-swap_threshold-parame.patch Normal file
View File

@ -0,0 +1,415 @@
From 9707219f4ec2b12012620a3e5cec90b61a3ca2c4 Mon Sep 17 00:00:00 2001
From: liubo <liubo254@huawei.com>
Date: Tue, 18 Jan 2022 11:03:13 +0800
Subject: [PATCH 16/33] etmem: add sysmem_threshold and swap_threshold
parameters to etmem
As a memory expansion tool, etmem performs memory swap operation
for the target process by default after it is enabled. However,
in some specific scenarios, in order to obtain the ultimate
performance of the business, it is necessary to consider
the timing of memory swapping by etmem.
Add the sysmem_threshold parameter to control the start and
stop of memory swap out when the system available memory
meets the requirements.
Add the swap_threshold parameter to limit the absolute
value of the memory size reserved by the process in DRAM.
When the target process memory is lower than this value, do not
swap out any memory.
Signed-off-by: liubo <liubo254@huawei.com>
---
etmem/conf/slide_conf.yaml | 2 +
etmem/inc/etmemd_inc/etmemd_common.h | 10 +++
etmem/inc/etmemd_inc/etmemd_project_exp.h | 1 +
etmem/inc/etmemd_inc/etmemd_slide.h | 1 +
etmem/src/etmemd_src/etmemd_common.c | 58 +++++++++++++-
etmem/src/etmemd_src/etmemd_project.c | 32 ++++++--
etmem/src/etmemd_src/etmemd_slide.c | 123 ++++++++++++++++++++++++++++++
7 files changed, 220 insertions(+), 7 deletions(-)
diff --git a/etmem/conf/slide_conf.yaml b/etmem/conf/slide_conf.yaml
index 75f0220..511d657 100644
--- a/etmem/conf/slide_conf.yaml
+++ b/etmem/conf/slide_conf.yaml
@@ -4,6 +4,7 @@ scan_type=page
loop=1
interval=1
sleep=1
+sysmem_threshold=50
[engine]
name=slide
@@ -17,3 +18,4 @@ type=name
value=mysql
T=1
max_threads=1
+swap_threshold=10g
diff --git a/etmem/inc/etmemd_inc/etmemd_common.h b/etmem/inc/etmemd_inc/etmemd_common.h
index 8d18f8a..576d38a 100644
--- a/etmem/inc/etmemd_inc/etmemd_common.h
+++ b/etmem/inc/etmemd_inc/etmemd_common.h
@@ -21,6 +21,7 @@
#define PROC_PATH "/proc/"
#define STATUS_FILE "/status"
+#define PROC_MEMINFO "meminfo"
#define SWAPIN "SwapIN"
#define VMRSS "VmRSS"
#define VMSWAP "VmSwap"
@@ -30,14 +31,21 @@
#define ETMEMD_MAX_PARAMETER_NUM 6
#define BYTE_TO_KB(s) ((s) >> 10)
#define KB_TO_BYTE(s) ((s) << 10)
+#define CONVERT_GB_2_KB (1024 * 1024)
#define ARRAY_SIZE(array) (sizeof(array) / sizeof((array)[0]))
/* in some system the max length of pid may be larger than 5, so we use 10 herr */
#define PID_STR_MAX_LEN 10
+#define SWAP_THRESHOLD_MAX_LEN 10
#define PIPE_FD_LEN 2
+enum swap_type {
+ DONT_SWAP = 0,
+ DO_SWAP,
+};
+
/*
* function: parse cmdline passed to etmemd server.
*
@@ -65,4 +73,6 @@ int get_mem_from_proc_file(const char *pid, const char *file_name, unsigned long
int dprintf_all(int fd, const char *format, ...);
+int get_swap_threshold_inKB(char *string);
+
#endif
diff --git a/etmem/inc/etmemd_inc/etmemd_project_exp.h b/etmem/inc/etmemd_inc/etmemd_project_exp.h
index 8740f7e..fc3c85e 100644
--- a/etmem/inc/etmemd_inc/etmemd_project_exp.h
+++ b/etmem/inc/etmemd_inc/etmemd_project_exp.h
@@ -42,6 +42,7 @@ struct project {
char *name;
enum scan_type type;
void *scan_param;
+ int sysmem_threshold;
bool start;
struct engine *engs;
diff --git a/etmem/inc/etmemd_inc/etmemd_slide.h b/etmem/inc/etmemd_inc/etmemd_slide.h
index 93de502..7c80502 100644
--- a/etmem/inc/etmemd_inc/etmemd_slide.h
+++ b/etmem/inc/etmemd_inc/etmemd_slide.h
@@ -22,6 +22,7 @@
struct slide_params {
struct task_executor *executor;
int t; /* watermark */
+ int swap_threshold;
uint8_t dram_percent;
};
diff --git a/etmem/src/etmemd_src/etmemd_common.c b/etmem/src/etmemd_src/etmemd_common.c
index ebf6232..caa5826 100644
--- a/etmem/src/etmemd_src/etmemd_common.c
+++ b/etmem/src/etmemd_src/etmemd_common.c
@@ -256,7 +256,7 @@ static char *etmemd_get_proc_file_str(const char *pid, const char *file)
char *file_name = NULL;
size_t file_str_size;
- file_str_size = strlen(PROC_PATH) + strlen(pid) + strlen(file) + 1;
+ file_str_size = strlen(PROC_PATH) + strlen(file) + 1 + (pid == NULL ? 0 : strlen(pid));
file_name = (char *)calloc(file_str_size, sizeof(char));
if (file_name == NULL) {
etmemd_log(ETMEMD_LOG_ERR, "malloc for %s path fail\n", file);
@@ -264,7 +264,7 @@ static char *etmemd_get_proc_file_str(const char *pid, const char *file)
}
if (snprintf_s(file_name, file_str_size, file_str_size - 1,
- "%s%s%s", PROC_PATH, pid, file) == -1) {
+ "%s%s%s", PROC_PATH, pid ? pid : "", file) == -1) {
etmemd_log(ETMEMD_LOG_ERR, "snprintf for %s fail\n", file);
free(file_name);
return NULL;
@@ -495,3 +495,57 @@ unsigned long get_pagesize(void)
return (unsigned long)pagesize;
}
+
+int get_swap_threshold_inKB(char *string)
+{
+ int len;
+ int i;
+ int ret = -1;
+ char *swap_threshold_string = NULL;
+ int swap_threshold_inGB;
+ int swap_threshold_inKB;
+
+ if (string == NULL) {
+ goto out;
+ }
+
+ len = strlen(string);
+ if (len > SWAP_THRESHOLD_MAX_LEN) {
+ etmemd_log(ETMEMD_LOG_ERR, "swap_threshold string is too long.\n");
+ goto out;
+ }
+
+ swap_threshold_string = (char *)calloc(len, sizeof(char));
+ if (swap_threshold_string == NULL) {
+ etmemd_log(ETMEMD_LOG_ERR, "calloc swap_threshold_string fail.\n");
+ goto out;
+ }
+
+ for (i = 0; i < len - 1; i++) {
+ if (isdigit(string[i])) {
+ swap_threshold_string[i] = string[i];
+ continue;
+ }
+ etmemd_log(ETMEMD_LOG_ERR, "the swap_threshold contain wrong parameter.\n");
+ goto free_out;
+ }
+
+ if (string[i] != 'g' && string[i] != 'G') {
+ etmemd_log(ETMEMD_LOG_ERR, "the swap_threshold should in G or g.\n");
+ goto free_out;
+ }
+
+ if (get_int_value(swap_threshold_string, &swap_threshold_inGB) != 0) {
+ etmemd_log(ETMEMD_LOG_ERR, "get_int_value swap_threshold faild.\n");
+ goto free_out;
+ }
+
+ swap_threshold_inKB = swap_threshold_inGB * CONVERT_GB_2_KB;
+ ret = swap_threshold_inKB;
+
+free_out:
+ free(swap_threshold_string);
+
+out:
+ return ret;
+}
diff --git a/etmem/src/etmemd_src/etmemd_project.c b/etmem/src/etmemd_src/etmemd_project.c
index fa4293b..459e140 100644
--- a/etmem/src/etmemd_src/etmemd_project.c
+++ b/etmem/src/etmemd_src/etmemd_project.c
@@ -30,12 +30,13 @@
#include "etmemd_file.h"
#include "etmemd_log.h"
-#define MAX_INTERVAL_VALUE 1200
-#define MAX_SLEEP_VALUE 1200
-#define MAX_LOOP_VALUE 120
+#define MAX_INTERVAL_VALUE 1200
+#define MAX_SLEEP_VALUE 1200
+#define MAX_LOOP_VALUE 120
+#define MAX_SYSMEM_THRESHOLD_VALUE 100
-#define MAX_OBJ_NAME_LEN 64
-#define MIN_NR_MIN_VAL 3
+#define MAX_OBJ_NAME_LEN 64
+#define MIN_NR_MIN_VAL 3
static SLIST_HEAD(project_list, project) g_projects = SLIST_HEAD_INITIALIZER(g_projects);
@@ -630,9 +631,27 @@ static int fill_project_scan_type(void *obj, void *val)
return 0;
}
+/* fill the project parameter: sysmem_threshold
+ * sysmem_threshold: [0, 100]. do not swap any memory out if system free memory is higher than sysmem_threshold */
+static int fill_project_sysmem_threshold(void *obj, void *val)
+{
+ struct project *proj = (struct project *)obj;
+ int sysmem_threshold = parse_to_int(val);
+
+ if (sysmem_threshold < 0 || sysmem_threshold > MAX_SYSMEM_THRESHOLD_VALUE) {
+ etmemd_log(ETMEMD_LOG_WARN, "invaild project sysmem_threshold value %d, it must between 0 and 100.\n",
+ sysmem_threshold, MAX_SYSMEM_THRESHOLD_VALUE);
+ sysmem_threshold = -1;
+ }
+
+ proj->sysmem_threshold = sysmem_threshold;
+ return 0;
+}
+
static struct config_item g_project_config_items[] = {
{"name", STR_VAL, fill_project_name, false},
{"scan_type", STR_VAL, fill_project_scan_type, false},
+ {"sysmem_threshold", INT_VAL, fill_project_sysmem_threshold, true},
};
static void clear_project(struct project *proj)
@@ -688,6 +707,9 @@ enum opt_result etmemd_project_add(GKeyFile *config)
etmemd_log(ETMEMD_LOG_ERR, "alloc memory for project fail\n");
return OPT_INTER_ERR;
}
+
+ proj->sysmem_threshold = -1;
+
if (project_fill_by_conf(config, proj) != 0) {
etmemd_log(ETMEMD_LOG_ERR, "fill project from configuration file fail\n");
free(proj);
diff --git a/etmem/src/etmemd_src/etmemd_slide.c b/etmem/src/etmemd_src/etmemd_slide.c
index 8362224..cbc4b17 100644
--- a/etmem/src/etmemd_src/etmemd_slide.c
+++ b/etmem/src/etmemd_src/etmemd_slide.c
@@ -17,6 +17,7 @@
#include <stdio.h>
#include <string.h>
#include <malloc.h>
+#include <unistd.h>
#include "securec.h"
#include "etmemd_log.h"
@@ -106,6 +107,104 @@ static int slide_do_migrate(unsigned int pid, const struct memory_grade *memory_
return ret;
}
+static int check_sysmem_lower_threshold(struct task_pid *tk_pid)
+{
+ unsigned long mem_total;
+ unsigned long mem_free;
+ int vm_cmp;
+ int ret;
+
+ ret = get_mem_from_proc_file(NULL, PROC_MEMINFO, &mem_total, "MemTotal");
+ if (ret != 0) {
+ etmemd_log(ETMEMD_LOG_ERR, "get memtotal fail\n");
+ return DONT_SWAP;
+ }
+
+ ret = get_mem_from_proc_file(NULL, PROC_MEMINFO, &mem_free, "MemFree");
+ if (ret != 0) {
+ etmemd_log(ETMEMD_LOG_ERR, "get memfree fail\n");
+ return DONT_SWAP;
+ }
+
+ /* Calculate the free memory percentage in 0 - 100 */
+ vm_cmp = (mem_free * 100) / mem_total;
+ if (vm_cmp < tk_pid->tk->eng->proj->sysmem_threshold) {
+ return DO_SWAP;
+ }
+
+ return DONT_SWAP;
+}
+
+static int check_pid_should_swap(const char *pid, unsigned long vmrss, const struct task_pid *tk_pid)
+{
+ unsigned long vmswap;
+ unsigned long vmcmp;
+ int ret;
+
+ ret = get_mem_from_proc_file(pid, STATUS_FILE, &vmswap, "VmSwap");
+ if (ret != 0) {
+ etmemd_log(ETMEMD_LOG_ERR, "get VmSwap fail\n");
+ return DONT_SWAP;
+ }
+
+ /* Calculate the total amount of memory that can be swappout for the current process
+ * and check whether the memory is larger than the current swapout amount.
+ * If true, continue swap-out; otherwise, abort the swap-out process. */
+ vmcmp = (vmrss + vmswap) / 100 * tk_pid->tk->eng->proj->sysmem_threshold;
+ if (vmcmp > vmswap) {
+ return DO_SWAP;
+ }
+
+ return DONT_SWAP;
+}
+
+static int check_pidmem_lower_threshold(struct task_pid *tk_pid)
+{
+ struct slide_params *params = NULL;
+ unsigned long vmrss;
+ int ret;
+ char pid_str[PID_STR_MAX_LEN] = {0};
+
+ params = (struct slide_params *)tk_pid->tk->params;
+ if (params == NULL) {
+ return DONT_SWAP;
+ }
+
+ if (snprintf_s(pid_str, PID_STR_MAX_LEN, PID_STR_MAX_LEN - 1, "%u", tk_pid->pid) <= 0) {
+ etmemd_log(ETMEMD_LOG_ERR, "snprintf pid fail %u", tk_pid->pid);
+ return DONT_SWAP;
+ }
+
+ ret = get_mem_from_proc_file(pid_str, STATUS_FILE, &vmrss, "VmRSS");
+ if (ret != 0) {
+ etmemd_log(ETMEMD_LOG_ERR, "get VmRSS fail\n");
+ return DONT_SWAP;
+ }
+
+ if (params->swap_threshold == 0) {
+ return check_pid_should_swap(pid_str, vmrss, tk_pid);
+ }
+
+ if ((int)vmrss > params->swap_threshold) {
+ return DO_SWAP;
+ }
+
+ return DONT_SWAP;
+}
+
+static int check_should_swap(struct task_pid *tk_pid)
+{
+ if (tk_pid->tk->eng->proj->sysmem_threshold == -1) {
+ return DO_SWAP;
+ }
+
+ if (check_sysmem_lower_threshold(tk_pid) == DONT_SWAP) {
+ return DONT_SWAP;
+ }
+
+ return check_pidmem_lower_threshold(tk_pid);
+}
+
static void *slide_executor(void *arg)
{
struct task_pid *tk_pid = (struct task_pid *)arg;
@@ -113,6 +212,10 @@ static void *slide_executor(void *arg)
struct memory_grade *memory_grade = NULL;
struct page_sort *page_sort = NULL;
+ if (check_should_swap(tk_pid) == DONT_SWAP) {
+ return NULL;
+ }
+
/* register cleanup function in case of unexpected cancellation detected,
* and register for memory_grade first, because it needs to clean after page_refs is cleaned */
pthread_cleanup_push(clean_memory_grade_unexpected, &memory_grade);
@@ -194,8 +297,28 @@ static int fill_task_dram_percent(void *obj, void *val)
return 0;
}
+static int fill_task_swap_threshold(void *obj, void *val)
+{
+ struct slide_params *params = (struct slide_params *)obj;
+ char *swap_threshold_string = (char *)val;
+ int swap_threshold = get_swap_threshold_inKB(swap_threshold_string);
+
+ free(swap_threshold_string);
+
+ if (swap_threshold < 0) {
+ etmemd_log(ETMEMD_LOG_WARN,
+ "parse swap_threshold failed.\n");
+ return -1;
+ }
+
+ params->swap_threshold = swap_threshold;
+
+ return 0;
+}
+
static struct config_item g_slide_task_config_items[] = {
{"T", INT_VAL, fill_task_threshold, false},
+ {"swap_threshold", STR_VAL, fill_task_swap_threshold, true},
{"dram_percent", INT_VAL, fill_task_dram_percent, true},
};
--
1.8.3.1

552
0067-etmem-add-swapcache-reclaim-to-etmem.patch Normal file
View File

@ -0,0 +1,552 @@
From 8a7c297694bfad83bdc826aea3c0fea84098a4fb Mon Sep 17 00:00:00 2001
From: liubo <liubo254@huawei.com>
Date: Tue, 18 Jan 2022 15:21:13 +0800
Subject: [PATCH 17/33] etmem: add swapcache reclaim to etmem
When etmem performs the memory swap operation, it will
occupy part of the swapcache memory. To further save
memory, the swapcache memory recovery function is
added, which depends on etmem_swap.ko
Add swapcache_high_wmark and swapcache_low_wmark field
to set the available watermark of swapcache memory.
When the swapcache memory usage is higher than high_wmark,
the swapcache memory recovery is triggered until it is less
than low wmark.
Signed-off-by: liubo <liubo254@huawei.com>
---
etmem/conf/slide_conf.yaml | 2 +
etmem/inc/etmemd_inc/etmemd_common.h | 50 ++++++++-----
etmem/inc/etmemd_inc/etmemd_migrate.h | 1 +
etmem/inc/etmemd_inc/etmemd_project_exp.h | 3 +
etmem/src/etmemd_src/etmemd_common.c | 48 +++++++------
etmem/src/etmemd_src/etmemd_cslide.c | 12 +++-
etmem/src/etmemd_src/etmemd_migrate.c | 113 +++++++++++++++++++++++++++++-
etmem/src/etmemd_src/etmemd_project.c | 56 ++++++++++++++-
etmem/src/etmemd_src/etmemd_scan.c | 14 +++-
etmem/src/etmemd_src/etmemd_slide.c | 4 ++
10 files changed, 255 insertions(+), 48 deletions(-)
diff --git a/etmem/conf/slide_conf.yaml b/etmem/conf/slide_conf.yaml
index 511d657..f55c508 100644
--- a/etmem/conf/slide_conf.yaml
+++ b/etmem/conf/slide_conf.yaml
@@ -5,6 +5,8 @@ loop=1
interval=1
sleep=1
sysmem_threshold=50
+swapcache_high_wmark=10
+swapcache_low_wmark=6
[engine]
name=slide
diff --git a/etmem/inc/etmemd_inc/etmemd_common.h b/etmem/inc/etmemd_inc/etmemd_common.h
index 576d38a..ced606e 100644
--- a/etmem/inc/etmemd_inc/etmemd_common.h
+++ b/etmem/inc/etmemd_inc/etmemd_common.h
@@ -18,34 +18,47 @@
#include <stdio.h>
#include <stdbool.h>
+#include <sys/ioctl.h>
-#define PROC_PATH "/proc/"
-#define STATUS_FILE "/status"
-#define PROC_MEMINFO "meminfo"
-#define SWAPIN "SwapIN"
-#define VMRSS "VmRSS"
-#define VMSWAP "VmSwap"
-#define FILE_LINE_MAX_LEN 1024
-#define KEY_VALUE_MAX_LEN 64
-#define DECIMAL_RADIX 10
-#define ETMEMD_MAX_PARAMETER_NUM 6
-#define BYTE_TO_KB(s) ((s) >> 10)
-#define KB_TO_BYTE(s) ((s) << 10)
-#define CONVERT_GB_2_KB (1024 * 1024)
-
-#define ARRAY_SIZE(array) (sizeof(array) / sizeof((array)[0]))
+#define PROC_PATH "/proc/"
+#define STATUS_FILE "/status"
+#define PROC_MEMINFO "meminfo"
+#define SWAPIN "SwapIN"
+#define VMRSS "VmRSS"
+#define VMSWAP "VmSwap"
+
+#define FILE_LINE_MAX_LEN 1024
+#define KEY_VALUE_MAX_LEN 64
+#define DECIMAL_RADIX 10
+#define ETMEMD_MAX_PARAMETER_NUM 6
+
+#define BYTE_TO_KB(s) ((s) >> 10)
+#define KB_TO_BYTE(s) ((s) << 10)
+#define CONVERT_GB_2_KB (1024 * 1024)
+
+#define MAX_SWAPCACHE_WMARK_VALUE 100
+
+#define ARRAY_SIZE(array) (sizeof(array) / sizeof((array)[0]))
/* in some system the max length of pid may be larger than 5, so we use 10 herr */
-#define PID_STR_MAX_LEN 10
+#define PID_STR_MAX_LEN 10
#define SWAP_THRESHOLD_MAX_LEN 10
-#define PIPE_FD_LEN 2
+#define PIPE_FD_LEN 2
+
+#define IDLE_SCAN_MAGIC 0x66
+#define IDLE_SCAN_ADD_FLAGS _IOW(IDLE_SCAN_MAGIC, 0x0, unsigned int)
enum swap_type {
DONT_SWAP = 0,
DO_SWAP,
};
+struct ioctl_para {
+ unsigned long ioctl_cmd;
+ int ioctl_parameter;
+};
+
/*
* function: parse cmdline passed to etmemd server.
*
@@ -65,7 +78,8 @@ int get_unsigned_int_value(const char *val, unsigned int *value);
int get_unsigned_long_value(const char *val, unsigned long *value);
void etmemd_safe_free(void **ptr);
-FILE *etmemd_get_proc_file(const char *pid, const char *file, int flags, const char *mode);
+FILE *etmemd_get_proc_file(const char *pid, const char *file, const char *mode);
+int etmemd_send_ioctl_cmd(FILE *fp, struct ioctl_para *request);
int get_keyword_and_value(const char *str, char *key, char *val);
unsigned long get_pagesize(void);
diff --git a/etmem/inc/etmemd_inc/etmemd_migrate.h b/etmem/inc/etmemd_inc/etmemd_migrate.h
index ef20bde..f8eb621 100644
--- a/etmem/inc/etmemd_inc/etmemd_migrate.h
+++ b/etmem/inc/etmemd_inc/etmemd_migrate.h
@@ -27,5 +27,6 @@
#define SWAP_ADDR_LEN 20
int etmemd_grade_migrate(const char* pid, const struct memory_grade *memory_grade);
+int etmemd_reclaim_swapcache(const struct task_pid *tk_pid);
unsigned long check_should_migrate(const struct task_pid *tk_pid);
#endif
diff --git a/etmem/inc/etmemd_inc/etmemd_project_exp.h b/etmem/inc/etmemd_inc/etmemd_project_exp.h
index fc3c85e..2fe8d90 100644
--- a/etmem/inc/etmemd_inc/etmemd_project_exp.h
+++ b/etmem/inc/etmemd_inc/etmemd_project_exp.h
@@ -43,7 +43,10 @@ struct project {
enum scan_type type;
void *scan_param;
int sysmem_threshold;
+ int swapcache_high_wmark;
+ int swapcache_low_wmark;
bool start;
+ bool wmark_set;
struct engine *engs;
SLIST_ENTRY(project) entry;
diff --git a/etmem/src/etmemd_src/etmemd_common.c b/etmem/src/etmemd_src/etmemd_common.c
index caa5826..bb72fd0 100644
--- a/etmem/src/etmemd_src/etmemd_common.c
+++ b/etmem/src/etmemd_src/etmemd_common.c
@@ -32,9 +32,6 @@
#include "etmemd_rpc.h"
#include "etmemd_log.h"
-#define IDLE_SCAN_MAGIC 0x66
-#define IDLE_SCAN_ADD_FLAGS _IOW(IDLE_SCAN_MAGIC, 0x0, unsigned int)
-
static void usage(void)
{
printf("\nusage of etmemd:\n"
@@ -273,10 +270,32 @@ static char *etmemd_get_proc_file_str(const char *pid, const char *file)
return file_name;
}
-FILE *etmemd_get_proc_file(const char *pid, const char *file, int flags, const char *mode)
+int etmemd_send_ioctl_cmd(FILE *fp, struct ioctl_para *request)
{
- char *file_name = NULL;
int fd = -1;
+
+ if (fp == NULL) {
+ etmemd_log(ETMEMD_LOG_ERR, "send ioctl cmd fail, fp is null\n");
+ return -1;
+ }
+
+ fd = fileno(fp);
+ if (fd < 0) {
+ etmemd_log(ETMEMD_LOG_ERR, "send ioctl cmd fail, get fd fail\n");
+ return -1;
+ }
+
+ if (request == NULL || ioctl(fd, request->ioctl_cmd, &request->ioctl_parameter) != 0) {
+ etmemd_log(ETMEMD_LOG_ERR, "send ioctl cmd fail, request is wrong\n");
+ return -1;
+ }
+
+ return 0;
+}
+
+FILE *etmemd_get_proc_file(const char *pid, const char *file, const char *mode)
+{
+ char *file_name = NULL;
FILE *fp = NULL;
file_name = etmemd_get_proc_file_str(pid, file);
@@ -287,25 +306,8 @@ FILE *etmemd_get_proc_file(const char *pid, const char *file, int flags, const c
fp = fopen(file_name, mode);
if (fp == NULL) {
etmemd_log(ETMEMD_LOG_ERR, "open file %s fail\n", file_name);
- goto free_file_name;
- }
-
- fd = fileno(fp);
- if (fd < 0) {
- etmemd_log(ETMEMD_LOG_ERR, "get fd of file %s fail\n", file_name);
- fclose(fp);
- fp = NULL;
- goto free_file_name;
- }
-
- if (flags != 0 && ioctl(fd, IDLE_SCAN_ADD_FLAGS, &flags) != 0) {
- etmemd_log(ETMEMD_LOG_ERR, "set idle flags for %s fail with %s\n", pid, strerror(errno));
- fclose(fp);
- fp = NULL;
- goto free_file_name;
}
-free_file_name:
free(file_name);
return fp;
}
@@ -453,7 +455,7 @@ int get_mem_from_proc_file(const char *pid, const char *file_name, unsigned long
unsigned long val;
int ret = -1;
- file = etmemd_get_proc_file(pid, file_name, 0, "r");
+ file = etmemd_get_proc_file(pid, file_name, "r");
if (file == NULL) {
etmemd_log(ETMEMD_LOG_ERR, "cannot open %s for pid %s\n", file_name, pid);
return ret;
diff --git a/etmem/src/etmemd_src/etmemd_cslide.c b/etmem/src/etmemd_src/etmemd_cslide.c
index b3d1637..cbaa2e8 100644
--- a/etmem/src/etmemd_src/etmemd_cslide.c
+++ b/etmem/src/etmemd_src/etmemd_cslide.c
@@ -1280,18 +1280,28 @@ static int cslide_scan_vmas(struct cslide_pid_params *params)
uint64_t i;
int fd;
struct cslide_task_params *task_params = params->task_params;
+ struct ioctl_para ioctl_para = {
+ .ioctl_cmd = IDLE_SCAN_ADD_FLAGS,
+ .ioctl_parameter = task_params->scan_flags,
+ };
if (snprintf_s(pid, PID_STR_MAX_LEN, PID_STR_MAX_LEN - 1, "%u", params->pid) <= 0) {
etmemd_log(ETMEMD_LOG_ERR, "snpintf pid %u fail\n", params->pid);
return -1;
}
- scan_fp = etmemd_get_proc_file(pid, IDLE_SCAN_FILE, task_params->scan_flags, "r");
+ scan_fp = etmemd_get_proc_file(pid, IDLE_SCAN_FILE, "r");
if (scan_fp == NULL) {
etmemd_log(ETMEMD_LOG_ERR, "open %s file for pid %u fail\n", IDLE_SCAN_FILE, params->pid);
return -1;
}
+ if (task_params->scan_flags != 0 && etmemd_send_ioctl_cmd(scan_fp, &ioctl_para) != 0) {
+ etmemd_log(ETMEMD_LOG_ERR, "etmemd send_ioctl_cmd %s file for pid %u fail\n", IDLE_SCAN_FILE, params->pid);
+ fclose(scan_fp);
+ return -1;
+ }
+
fd = fileno(scan_fp);
if (fd == -1) {
fclose(scan_fp);
diff --git a/etmem/src/etmemd_src/etmemd_migrate.c b/etmem/src/etmemd_src/etmemd_migrate.c
index 639d570..87bfde0 100644
--- a/etmem/src/etmemd_src/etmemd_migrate.c
+++ b/etmem/src/etmemd_src/etmemd_migrate.c
@@ -15,14 +15,24 @@
#include <stdio.h>
#include <stdlib.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
#include "securec.h"
#include "etmemd.h"
#include "etmemd_migrate.h"
+#include "etmemd_project.h"
#include "etmemd_common.h"
#include "etmemd_slide.h"
#include "etmemd_log.h"
+#define RECLAIM_SWAPCACHE_MAGIC 0x77
+#define RECLAIM_SWAPCACHE_ON _IOW(RECLAIM_SWAPCACHE_MAGIC, 0x1, unsigned int)
+#define SET_SWAPCACHE_WMARK _IOW(RECLAIM_SWAPCACHE_MAGIC, 0x2, unsigned int)
+
static char *get_swap_string(struct page_refs **page_refs, int batchsize)
{
char *swap_str = NULL;
@@ -70,7 +80,7 @@ static int etmemd_migrate_mem(const char *pid, const char *grade_path, struct pa
return 0;
}
- fp = etmemd_get_proc_file(pid, grade_path, 0, "r+");
+ fp = etmemd_get_proc_file(pid, grade_path, "r+");
if (fp == NULL) {
etmemd_log(ETMEMD_LOG_ERR, "cannot open %s for pid %s\n", grade_path, pid);
return -1;
@@ -98,6 +108,107 @@ static int etmemd_migrate_mem(const char *pid, const char *grade_path, struct pa
return 0;
}
+static bool check_should_reclaim_swapcache(const struct task_pid *tk_pid)
+{
+ struct project *proj = tk_pid->tk->eng->proj;
+ unsigned long mem_total;
+ unsigned long swapcache_total;
+ int ret;
+
+ if (proj->swapcache_high_wmark == 0) {
+ return false;
+ }
+
+ ret = get_mem_from_proc_file(NULL, PROC_MEMINFO, &mem_total, "MemTotal");
+ if (ret != 0) {
+ etmemd_log(ETMEMD_LOG_ERR, "get memtotal fail\n");
+ return false;
+ }
+
+ ret = get_mem_from_proc_file(NULL, PROC_MEMINFO, &swapcache_total, "SwapCached");
+ if (ret != 0) {
+ etmemd_log(ETMEMD_LOG_ERR, "get swapcache_total fail\n");
+ return false;
+ }
+
+ if ((swapcache_total / proj->swapcache_high_wmark) <= (mem_total / MAX_SWAPCACHE_WMARK_VALUE)) {
+ return false;
+ }
+
+ return true;
+}
+
+static int set_swapcache_wmark(const struct task_pid *tk_pid, const char *pid_str)
+{
+ int swapcache_wmark;
+ struct project *proj = tk_pid->tk->eng->proj;
+ FILE *fp = NULL;
+ struct ioctl_para ioctl_para = {
+ .ioctl_cmd = SET_SWAPCACHE_WMARK,
+ };
+
+ swapcache_wmark = (proj->swapcache_low_wmark & 0x00ff) | (proj->swapcache_high_wmark << 8 & 0xff00);
+ ioctl_para.ioctl_parameter = swapcache_wmark;
+
+ fp = etmemd_get_proc_file(pid_str, COLD_PAGE, "r+");
+ if (fp == NULL) {
+ etmemd_log(ETMEMD_LOG_ERR, "get proc file %s failed.\n", COLD_PAGE);
+ return -1;
+ }
+
+ if (etmemd_send_ioctl_cmd(fp, &ioctl_para) != 0) {
+ fclose(fp);
+ etmemd_log(ETMEMD_LOG_ERR, "set_swapcache_wmark for pid %u fail\n", tk_pid->pid);
+ return -1;
+ }
+
+ fclose(fp);
+ return 0;
+}
+
+int etmemd_reclaim_swapcache(const struct task_pid *tk_pid)
+{
+ char pid_str[PID_STR_MAX_LEN] = {0};
+ FILE *fp = NULL;
+ struct ioctl_para ioctl_para = {
+ .ioctl_cmd = RECLAIM_SWAPCACHE_ON,
+ .ioctl_parameter = 0,
+ };
+
+ if (tk_pid == NULL) {
+ etmemd_log(ETMEMD_LOG_ERR, "tk_pid is null.\n");
+ return -1;
+ }
+
+ if (!check_should_reclaim_swapcache(tk_pid)) {
+ return 0;
+ }
+
+ if (snprintf_s(pid_str, PID_STR_MAX_LEN, PID_STR_MAX_LEN - 1, "%u", tk_pid->pid) <= 0) {
+ etmemd_log(ETMEMD_LOG_ERR, "snprintf pid fail %u", tk_pid->pid);
+ return -1;
+ }
+
+ if (!tk_pid->tk->eng->proj->wmark_set) {
+ set_swapcache_wmark(tk_pid, pid_str);
+ tk_pid->tk->eng->proj->wmark_set = true;
+ }
+
+ fp = etmemd_get_proc_file(pid_str, COLD_PAGE, "r+");
+ if (fp == NULL) {
+ etmemd_log(ETMEMD_LOG_ERR, "get proc file %s fail.\n", COLD_PAGE);
+ return -1;
+ }
+
+ if (etmemd_send_ioctl_cmd(fp, &ioctl_para) != 0) {
+ etmemd_log(ETMEMD_LOG_ERR, "etmemd_reclaim_swapcache fail\n");
+ fclose(fp);
+ return -1;
+ }
+
+ fclose(fp);
+ return 0;
+}
int etmemd_grade_migrate(const char *pid, const struct memory_grade *memory_grade)
{
diff --git a/etmem/src/etmemd_src/etmemd_project.c b/etmem/src/etmemd_src/etmemd_project.c
index 459e140..72d7335 100644
--- a/etmem/src/etmemd_src/etmemd_project.c
+++ b/etmem/src/etmemd_src/etmemd_project.c
@@ -639,19 +639,64 @@ static int fill_project_sysmem_threshold(void *obj, void *val)
int sysmem_threshold = parse_to_int(val);
if (sysmem_threshold < 0 || sysmem_threshold > MAX_SYSMEM_THRESHOLD_VALUE) {
- etmemd_log(ETMEMD_LOG_WARN, "invaild project sysmem_threshold value %d, it must between 0 and 100.\n",
- sysmem_threshold, MAX_SYSMEM_THRESHOLD_VALUE);
- sysmem_threshold = -1;
+ etmemd_log(ETMEMD_LOG_ERR, "invaild project sysmem_threshold value %d, it must between 0 and 100.\n",
+ sysmem_threshold);
+ return -1;
}
proj->sysmem_threshold = sysmem_threshold;
return 0;
}
+/* fill the project parameter: swapcache_low_wmark
+ * swapcache_low_wmark: [0, 100]. */
+static int fill_project_swapcache_low_wmark(void *obj, void *val)
+{
+ struct project *proj = (struct project *)obj;
+ int swapcache_low_wmark = parse_to_int(val);
+
+ if (swapcache_low_wmark < 0 || swapcache_low_wmark > MAX_SWAPCACHE_WMARK_VALUE) {
+ etmemd_log(ETMEMD_LOG_ERR, "invaild project swapcache_low_wmark value %d, it must between 0 and 100.\n",
+ swapcache_low_wmark);
+ return -1;
+ }
+
+ proj->swapcache_low_wmark = swapcache_low_wmark;
+ return 0;
+}
+
+/* fill the project parameter: swapcache_high_wmark
+ * swapcache_high_wmark: (0, 100]. */
+static int fill_project_swapcache_high_wmark(void *obj, void *val)
+{
+ struct project *proj = (struct project *)obj;
+ int swapcache_high_wmark = parse_to_int(val);
+
+ if (swapcache_high_wmark < 0 || swapcache_high_wmark > MAX_SWAPCACHE_WMARK_VALUE) {
+ etmemd_log(ETMEMD_LOG_ERR, "invaild project swapcache_high_wmark value %d, it must between 0 and 100.\n",
+ swapcache_high_wmark);
+ return -1;
+ }
+
+ proj->swapcache_high_wmark = swapcache_high_wmark;
+ return 0;
+}
+
+static bool check_swapcache_wmark_valid(struct project *proj)
+{
+ if (proj->swapcache_low_wmark > proj->swapcache_high_wmark) {
+ return false;
+ }
+
+ return true;
+}
+
static struct config_item g_project_config_items[] = {
{"name", STR_VAL, fill_project_name, false},
{"scan_type", STR_VAL, fill_project_scan_type, false},
{"sysmem_threshold", INT_VAL, fill_project_sysmem_threshold, true},
+ {"swapcache_high_wmark", INT_VAL, fill_project_swapcache_high_wmark, true},
+ {"swapcache_low_wmark", INT_VAL, fill_project_swapcache_low_wmark, true},
};
static void clear_project(struct project *proj)
@@ -675,6 +720,11 @@ static int project_fill_by_conf(GKeyFile *config, struct project *proj)
return -1;
}
+ if (!check_swapcache_wmark_valid(proj)) {
+ etmemd_log(ETMEMD_LOG_ERR, "swapcache wmark is not valid, low wmark: %d, high wmark: %d",
+ proj->swapcache_low_wmark, proj->swapcache_high_wmark);
+ return -1;
+ }
return 0;
}
diff --git a/etmem/src/etmemd_src/etmemd_scan.c b/etmem/src/etmemd_src/etmemd_scan.c
index 3ee018e..a1f8cdc 100644
--- a/etmem/src/etmemd_src/etmemd_scan.c
+++ b/etmem/src/etmemd_src/etmemd_scan.c
@@ -359,7 +359,7 @@ struct vmas *get_vmas_with_flags(const char *pid, char *vmflags_array[], int vmf
return NULL;
}
- fp = etmemd_get_proc_file(pid, maps_file, 0, "r");
+ fp = etmemd_get_proc_file(pid, maps_file, "r");
if (fp == NULL) {
etmemd_log(ETMEMD_LOG_ERR, "open %s file of %s fail\n", maps_file, pid);
free(ret_vmas);
@@ -680,13 +680,23 @@ int get_page_refs(const struct vmas *vmas, const char *pid, struct page_refs **p
struct vma *vma = vmas->vma_list;
struct page_refs **tmp_page_refs = NULL;
struct walk_address walk_address = {0, 0, 0};
+ struct ioctl_para ioctl_para = {
+ .ioctl_cmd = IDLE_SCAN_ADD_FLAGS,
+ .ioctl_parameter = flags,
+ };
- scan_fp = etmemd_get_proc_file(pid, IDLE_SCAN_FILE, flags, "r");
+ scan_fp = etmemd_get_proc_file(pid, IDLE_SCAN_FILE, "r");
if (scan_fp == NULL) {
etmemd_log(ETMEMD_LOG_ERR, "open %s file fail\n", IDLE_SCAN_FILE);
return -1;
}
+ if (flags != 0 && etmemd_send_ioctl_cmd(scan_fp, &ioctl_para) != 0) {
+ fclose(scan_fp);
+ etmemd_log(ETMEMD_LOG_ERR, "etmemd_send_ioctl_cmd %s file for pid %s fail\n", IDLE_SCAN_FILE, pid);
+ return -1;
+ }
+
fd = fileno(scan_fp);
if (fd == -1) {
etmemd_log(ETMEMD_LOG_ERR, "fileno file fail\n");
diff --git a/etmem/src/etmemd_src/etmemd_slide.c b/etmem/src/etmemd_src/etmemd_slide.c
index cbc4b17..c478fbd 100644
--- a/etmem/src/etmemd_src/etmemd_slide.c
+++ b/etmem/src/etmemd_src/etmemd_slide.c
@@ -256,6 +256,10 @@ scan_out:
etmemd_log(ETMEMD_LOG_DEBUG, "slide migrate for pid %u fail\n", tk_pid->pid);
}
+ if (etmemd_reclaim_swapcache(tk_pid) != 0) {
+ etmemd_log(ETMEMD_LOG_DEBUG, "etmemd_reclaim_swapcache pid %u fail\n", tk_pid->pid);
+ }
+
exit:
/* clean memory_grade here */
pthread_cleanup_pop(1);
--
1.8.3.1

434
0068-etmem-add-swap-flag-to-support-specified-page-swap-o.patch Normal file
View File

@ -0,0 +1,434 @@
From d6e4942b34bbcbfaec8b0d4702f0e385f8d267f1 Mon Sep 17 00:00:00 2001
From: liubo <liubo254@huawei.com>
Date: Tue, 18 Jan 2022 15:55:29 +0800
Subject: [PATCH 18/33] etmem: add swap flag to support specified page swap out
The existing memory expansion tool etmem swaps out
all pages that can be swapped out for the process by
default, unless the page is marked with lock flag.
The function of swapping out specified pages is add.
The process adds special flag for pages to be swapped
out. This function depends on etmem_scan module.
Added swap_flag field to indicate that a tagged swap
out is used for this process instead of the default
swap out.
Signed-off-by: liubo <liubo254@huawei.com>
---
etmem/conf/slide_conf.yaml | 1 +
etmem/inc/etmemd_inc/etmemd_common.h | 14 +++-----------
etmem/inc/etmemd_inc/etmemd_scan.h | 9 +++++++--
etmem/inc/etmemd_inc/etmemd_scan_exp.h | 1 +
etmem/inc/etmemd_inc/etmemd_slide.h | 7 ++++++-
etmem/inc/etmemd_inc/etmemd_task_exp.h | 1 +
etmem/src/etmemd_src/etmemd_common.c | 34 +++++++++++++++++++---------------
etmem/src/etmemd_src/etmemd_migrate.c | 8 ++++++--
etmem/src/etmemd_src/etmemd_scan.c | 24 ++++++++++++++++--------
etmem/src/etmemd_src/etmemd_slide.c | 12 ++++++------
etmem/src/etmemd_src/etmemd_task.c | 23 +++++++++++++++++++++++
11 files changed, 89 insertions(+), 45 deletions(-)
diff --git a/etmem/conf/slide_conf.yaml b/etmem/conf/slide_conf.yaml
index f55c508..8169b7d 100644
--- a/etmem/conf/slide_conf.yaml
+++ b/etmem/conf/slide_conf.yaml
@@ -21,3 +21,4 @@ value=mysql
T=1
max_threads=1
swap_threshold=10g
+swap_flag=yes
diff --git a/etmem/inc/etmemd_inc/etmemd_common.h b/etmem/inc/etmemd_inc/etmemd_common.h
index ced606e..03792a7 100644
--- a/etmem/inc/etmemd_inc/etmemd_common.h
+++ b/etmem/inc/etmemd_inc/etmemd_common.h
@@ -34,7 +34,7 @@
#define BYTE_TO_KB(s) ((s) >> 10)
#define KB_TO_BYTE(s) ((s) << 10)
-#define CONVERT_GB_2_KB (1024 * 1024)
+#define GB_TO_KB(s) ((s) << 20)
#define MAX_SWAPCACHE_WMARK_VALUE 100
@@ -46,17 +46,9 @@
#define PIPE_FD_LEN 2
-#define IDLE_SCAN_MAGIC 0x66
-#define IDLE_SCAN_ADD_FLAGS _IOW(IDLE_SCAN_MAGIC, 0x0, unsigned int)
-
-enum swap_type {
- DONT_SWAP = 0,
- DO_SWAP,
-};
-
struct ioctl_para {
unsigned long ioctl_cmd;
- int ioctl_parameter;
+ unsigned int ioctl_parameter;
};
/*
@@ -87,6 +79,6 @@ int get_mem_from_proc_file(const char *pid, const char *file_name, unsigned long
int dprintf_all(int fd, const char *format, ...);
-int get_swap_threshold_inKB(char *string);
+int get_swap_threshold_inKB(const char *string, unsigned long *value);
#endif
diff --git a/etmem/inc/etmemd_inc/etmemd_scan.h b/etmem/inc/etmemd_inc/etmemd_scan.h
index 9e5bcc4..7c25152 100644
--- a/etmem/inc/etmemd_inc/etmemd_scan.h
+++ b/etmem/inc/etmemd_inc/etmemd_scan.h
@@ -20,6 +20,7 @@
#include "etmemd.h"
#include "etmemd_task.h"
#include "etmemd_scan_exp.h"
+#include "etmemd_common.h"
#define VMA_SEG_CNT_MAX 6
#define VMA_PERMS_STR_LEN 5
@@ -34,7 +35,10 @@
#define SMAPS_FILE "/smaps"
#define VMFLAG_HEAD "VmFlags"
-#define ALL_SCAN_FLAGS (SCAN_AS_HUGE | SCAN_IGN_HOST)
+#define IDLE_SCAN_MAGIC 0x66
+#define IDLE_SCAN_ADD_FLAGS _IOW(IDLE_SCAN_MAGIC, 0x0, unsigned int)
+#define VMA_SCAN_ADD_FLAGS _IOW(IDLE_SCAN_MAGIC, 0x2, unsigned int)
+#define ALL_SCAN_FLAGS (SCAN_AS_HUGE | SCAN_IGN_HOST | VMA_SCAN_FLAG)
enum page_idle_type {
PTE_ACCESS = 0, /* 4k page */
@@ -70,7 +74,8 @@ struct page_refs *etmemd_do_scan(const struct task_pid *tpid, const struct task
void free_vmas(struct vmas *vmas);
struct page_refs **walk_vmas(int fd, struct walk_address *walk_address, struct page_refs **pf, unsigned long *use_rss);
-int get_page_refs(const struct vmas *vmas, const char *pid, struct page_refs **page_refs, unsigned long *use_rss, int flags);
+int get_page_refs(const struct vmas *vmas, const char *pid, struct page_refs **page_refs,
+ unsigned long *use_rss, struct ioctl_para *ioctl_para);
int split_vmflags(char ***vmflags_array, char *vmflags);
struct vmas *get_vmas_with_flags(const char *pid, char **vmflags_array, int vmflags_num, bool is_anon_only);
diff --git a/etmem/inc/etmemd_inc/etmemd_scan_exp.h b/etmem/inc/etmemd_inc/etmemd_scan_exp.h
index 1fd4379..7be925c 100644
--- a/etmem/inc/etmemd_inc/etmemd_scan_exp.h
+++ b/etmem/inc/etmemd_inc/etmemd_scan_exp.h
@@ -25,6 +25,7 @@
#define SCAN_AS_HUGE 0100000000 /* treat normal vm page as vm hugepage */
#define SCAN_IGN_HOST 0200000000 /* ignore host access when scan vm */
+#define VMA_SCAN_FLAG 0x1000 /* scan the specifics vma with flag */
enum {
VMA_STAT_READ = 0,
diff --git a/etmem/inc/etmemd_inc/etmemd_slide.h b/etmem/inc/etmemd_inc/etmemd_slide.h
index 7c80502..726c721 100644
--- a/etmem/inc/etmemd_inc/etmemd_slide.h
+++ b/etmem/inc/etmemd_inc/etmemd_slide.h
@@ -22,10 +22,15 @@
struct slide_params {
struct task_executor *executor;
int t; /* watermark */
- int swap_threshold;
+ unsigned long swap_threshold;
uint8_t dram_percent;
};
+enum swap_type {
+ DONT_SWAP = 0,
+ DO_SWAP,
+};
+
int fill_engine_type_slide(struct engine *eng, GKeyFile *config);
#endif
diff --git a/etmem/inc/etmemd_inc/etmemd_task_exp.h b/etmem/inc/etmemd_inc/etmemd_task_exp.h
index 33d505a..6f775b6 100644
--- a/etmem/inc/etmemd_inc/etmemd_task_exp.h
+++ b/etmem/inc/etmemd_inc/etmemd_task_exp.h
@@ -29,6 +29,7 @@ struct task {
char *value;
char *name;
int max_threads;
+ int swap_flag;
struct task_pid *pids;
struct engine *eng;
diff --git a/etmem/src/etmemd_src/etmemd_common.c b/etmem/src/etmemd_src/etmemd_common.c
index bb72fd0..dfbae6d 100644
--- a/etmem/src/etmemd_src/etmemd_common.c
+++ b/etmem/src/etmemd_src/etmemd_common.c
@@ -261,7 +261,7 @@ static char *etmemd_get_proc_file_str(const char *pid, const char *file)
}
if (snprintf_s(file_name, file_str_size, file_str_size - 1,
- "%s%s%s", PROC_PATH, pid ? pid : "", file) == -1) {
+ "%s%s%s", PROC_PATH, pid == NULL ? "" : pid, file) == -1) {
etmemd_log(ETMEMD_LOG_ERR, "snprintf for %s fail\n", file);
free(file_name);
return NULL;
@@ -274,8 +274,8 @@ int etmemd_send_ioctl_cmd(FILE *fp, struct ioctl_para *request)
{
int fd = -1;
- if (fp == NULL) {
- etmemd_log(ETMEMD_LOG_ERR, "send ioctl cmd fail, fp is null\n");
+ if (fp == NULL || request == NULL) {
+ etmemd_log(ETMEMD_LOG_ERR, "send ioctl cmd fail, para is null\n");
return -1;
}
@@ -285,8 +285,8 @@ int etmemd_send_ioctl_cmd(FILE *fp, struct ioctl_para *request)
return -1;
}
- if (request == NULL || ioctl(fd, request->ioctl_cmd, &request->ioctl_parameter) != 0) {
- etmemd_log(ETMEMD_LOG_ERR, "send ioctl cmd fail, request is wrong\n");
+ if (ioctl(fd, request->ioctl_cmd, &request->ioctl_parameter) != 0) {
+ etmemd_log(ETMEMD_LOG_ERR, "ioctl failed\n");
return -1;
}
@@ -298,6 +298,11 @@ FILE *etmemd_get_proc_file(const char *pid, const char *file, const char *mode)
char *file_name = NULL;
FILE *fp = NULL;
+ if (file == NULL) {
+ etmemd_log(ETMEMD_LOG_ERR, "etmemd_get_proc_file file should not be NULL\n");
+ return NULL;
+ }
+
file_name = etmemd_get_proc_file_str(pid, file);
if (file_name == NULL) {
return NULL;
@@ -498,22 +503,21 @@ unsigned long get_pagesize(void)
return (unsigned long)pagesize;
}
-int get_swap_threshold_inKB(char *string)
+int get_swap_threshold_inKB(const char *string, unsigned long *value)
{
int len;
int i;
int ret = -1;
char *swap_threshold_string = NULL;
- int swap_threshold_inGB;
- int swap_threshold_inKB;
+ unsigned long swap_threshold_inGB;
- if (string == NULL) {
+ if (string == NULL || value == NULL) {
goto out;
}
len = strlen(string);
- if (len > SWAP_THRESHOLD_MAX_LEN) {
- etmemd_log(ETMEMD_LOG_ERR, "swap_threshold string is too long.\n");
+ if (len == 0 || len > SWAP_THRESHOLD_MAX_LEN) {
+ etmemd_log(ETMEMD_LOG_ERR, "swap_threshold string is invalid.\n");
goto out;
}
@@ -537,13 +541,13 @@ int get_swap_threshold_inKB(char *string)
goto free_out;
}
- if (get_int_value(swap_threshold_string, &swap_threshold_inGB) != 0) {
- etmemd_log(ETMEMD_LOG_ERR, "get_int_value swap_threshold faild.\n");
+ if (get_unsigned_long_value(swap_threshold_string, &swap_threshold_inGB) != 0) {
+ etmemd_log(ETMEMD_LOG_ERR, "get_unsigned_long_value swap_threshold faild.\n");
goto free_out;
}
- swap_threshold_inKB = swap_threshold_inGB * CONVERT_GB_2_KB;
- ret = swap_threshold_inKB;
+ *value = GB_TO_KB(swap_threshold_inGB);
+ ret = 0;
free_out:
free(swap_threshold_string);
diff --git a/etmem/src/etmemd_src/etmemd_migrate.c b/etmem/src/etmemd_src/etmemd_migrate.c
index 87bfde0..a5cce41 100644
--- a/etmem/src/etmemd_src/etmemd_migrate.c
+++ b/etmem/src/etmemd_src/etmemd_migrate.c
@@ -131,7 +131,8 @@ static bool check_should_reclaim_swapcache(const struct task_pid *tk_pid)
return false;
}
- if ((swapcache_total / proj->swapcache_high_wmark) <= (mem_total / MAX_SWAPCACHE_WMARK_VALUE)) {
+ if (swapcache_total == 0 ||
+ (mem_total / swapcache_total) >= (unsigned long)(MAX_SWAPCACHE_WMARK_VALUE / proj->swapcache_high_wmark)) {
return false;
}
@@ -190,7 +191,10 @@ int etmemd_reclaim_swapcache(const struct task_pid *tk_pid)
}
if (!tk_pid->tk->eng->proj->wmark_set) {
- set_swapcache_wmark(tk_pid, pid_str);
+ if (set_swapcache_wmark(tk_pid, pid_str) != 0) {
+ etmemd_log(ETMEMD_LOG_ERR, "set_swapcache_wmark for pid %u fail\n", tk_pid->pid);
+ return -1;
+ }
tk_pid->tk->eng->proj->wmark_set = true;
}
diff --git a/etmem/src/etmemd_src/etmemd_scan.c b/etmem/src/etmemd_src/etmemd_scan.c
index a1f8cdc..e06ba92 100644
--- a/etmem/src/etmemd_src/etmemd_scan.c
+++ b/etmem/src/etmemd_src/etmemd_scan.c
@@ -672,7 +672,8 @@ struct page_refs **walk_vmas(int fd,
* this parameter is used only in the dynamic engine to calculate the swap-in rate.
* In other policies, NULL can be directly transmitted.
* */
-int get_page_refs(const struct vmas *vmas, const char *pid, struct page_refs **page_refs, unsigned long *use_rss, int flags)
+int get_page_refs(const struct vmas *vmas, const char *pid, struct page_refs **page_refs,
+ unsigned long *use_rss, struct ioctl_para *ioctl_para)
{
u_int64_t i;
FILE *scan_fp = NULL;
@@ -680,10 +681,6 @@ int get_page_refs(const struct vmas *vmas, const char *pid, struct page_refs **p
struct vma *vma = vmas->vma_list;
struct page_refs **tmp_page_refs = NULL;
struct walk_address walk_address = {0, 0, 0};
- struct ioctl_para ioctl_para = {
- .ioctl_cmd = IDLE_SCAN_ADD_FLAGS,
- .ioctl_parameter = flags,
- };
scan_fp = etmemd_get_proc_file(pid, IDLE_SCAN_FILE, "r");
if (scan_fp == NULL) {
@@ -691,7 +688,8 @@ int get_page_refs(const struct vmas *vmas, const char *pid, struct page_refs **p
return -1;
}
- if (flags != 0 && etmemd_send_ioctl_cmd(scan_fp, &ioctl_para) != 0) {
+ if (ioctl_para != NULL && ioctl_para->ioctl_parameter != 0
+ && etmemd_send_ioctl_cmd(scan_fp, ioctl_para) != 0) {
fclose(scan_fp);
etmemd_log(ETMEMD_LOG_ERR, "etmemd_send_ioctl_cmd %s file for pid %s fail\n", IDLE_SCAN_FILE, pid);
return -1;
@@ -734,6 +732,7 @@ int get_page_refs(const struct vmas *vmas, const char *pid, struct page_refs **p
int etmemd_get_page_refs(const struct vmas *vmas, const char *pid, struct page_refs **page_refs, int flags)
{
+ struct ioctl_para ioctl_para;
if (!g_exp_scan_inited) {
etmemd_log(ETMEMD_LOG_ERR, "scan module is not inited before etmemd_get_page_refs\n");
return -1;
@@ -744,7 +743,10 @@ int etmemd_get_page_refs(const struct vmas *vmas, const char *pid, struct page_r
return -1;
}
- return get_page_refs(vmas, pid, page_refs, NULL, flags & ALL_SCAN_FLAGS);
+ ioctl_para.ioctl_parameter = flags & ALL_SCAN_FLAGS;
+ ioctl_para.ioctl_cmd = IDLE_SCAN_ADD_FLAGS;
+
+ return get_page_refs(vmas, pid, page_refs, NULL, &ioctl_para);
}
void etmemd_free_page_refs(struct page_refs *pf)
@@ -765,6 +767,7 @@ struct page_refs *etmemd_do_scan(const struct task_pid *tpid, const struct task
struct page_refs *page_refs = NULL;
int ret;
char pid[PID_STR_MAX_LEN] = {0};
+ struct ioctl_para ioctl_para = {0};
if (tk == NULL) {
etmemd_log(ETMEMD_LOG_ERR, "task struct is null for pid %u\n", tpid->pid);
@@ -785,9 +788,14 @@ struct page_refs *etmemd_do_scan(const struct task_pid *tpid, const struct task
return NULL;
}
+ ioctl_para.ioctl_cmd = VMA_SCAN_ADD_FLAGS;
+ if (tk->swap_flag != 0) {
+ ioctl_para.ioctl_parameter = VMA_SCAN_FLAG;
+ }
+
/* loop for scanning idle_pages to get result of memory access. */
for (i = 0; i < page_scan->loop; i++) {
- ret = get_page_refs(vmas, pid, &page_refs, NULL, 0);
+ ret = get_page_refs(vmas, pid, &page_refs, NULL, &ioctl_para);
if (ret != 0) {
etmemd_log(ETMEMD_LOG_ERR, "scan operation failed\n");
/* free page_refs nodes already exist */
diff --git a/etmem/src/etmemd_src/etmemd_slide.c b/etmem/src/etmemd_src/etmemd_slide.c
index c478fbd..236778a 100644
--- a/etmem/src/etmemd_src/etmemd_slide.c
+++ b/etmem/src/etmemd_src/etmemd_slide.c
@@ -185,7 +185,7 @@ static int check_pidmem_lower_threshold(struct task_pid *tk_pid)
return check_pid_should_swap(pid_str, vmrss, tk_pid);
}
- if ((int)vmrss > params->swap_threshold) {
+ if (vmrss > params->swap_threshold) {
return DO_SWAP;
}
@@ -305,16 +305,16 @@ static int fill_task_swap_threshold(void *obj, void *val)
{
struct slide_params *params = (struct slide_params *)obj;
char *swap_threshold_string = (char *)val;
- int swap_threshold = get_swap_threshold_inKB(swap_threshold_string);
+ unsigned long swap_threshold;
- free(swap_threshold_string);
-
- if (swap_threshold < 0) {
+ if (get_swap_threshold_inKB(swap_threshold_string, &swap_threshold) != 0) {
etmemd_log(ETMEMD_LOG_WARN,
"parse swap_threshold failed.\n");
+ free(swap_threshold_string);
return -1;
}
-
+
+ free(swap_threshold_string);
params->swap_threshold = swap_threshold;
return 0;
diff --git a/etmem/src/etmemd_src/etmemd_task.c b/etmem/src/etmemd_src/etmemd_task.c
index 618245e..2a8cb3e 100644
--- a/etmem/src/etmemd_src/etmemd_task.c
+++ b/etmem/src/etmemd_src/etmemd_task.c
@@ -470,10 +470,33 @@ static int fill_task_threads(void *obj, void *val)
return 0;
}
+static int fill_task_swap_flag(void *obj, void *val)
+{
+ struct task *tk = (struct task *)obj;
+ char *swap_flag = (char *)val;
+
+ if (strcmp(swap_flag, "yes") == 0) {
+ tk->swap_flag = 1;
+ free(val);
+ return 0;
+ }
+
+ if (strcmp(swap_flag, "no") == 0) {
+ tk->swap_flag = 0;
+ free(val);
+ return 0;
+ }
+
+ free(val);
+ etmemd_log(ETMEMD_LOG_ERR, "swap_flag para is not valid.\n");
+ return -1;
+}
+
struct config_item g_task_config_items[] = {
{"name", STR_VAL, fill_task_name, false},
{"type", STR_VAL, fill_task_type, false},
{"value", STR_VAL, fill_task_value, false},
+ {"swap_flag", STR_VAL, fill_task_swap_flag, true},
{"max_threads", INT_VAL, fill_task_threads, true},
};
--
1.8.3.1

93
0069-etmem-fix-the-swapcache-wmark-configuration-parse-er.patch Normal file
View File

@ -0,0 +1,93 @@
From fff3255965293f42b9b6af79d0766110411c49d4 Mon Sep 17 00:00:00 2001
From: liubo <liubo254@huawei.com>
Date: Sat, 12 Feb 2022 10:15:28 +0800
Subject: [PATCH 19/33] etmem: fix the swapcache wmark configuration parse
error
swapcache_high_wmark and swapcache_low_wmark should
appear in pairs, missing either part should report
an error.
In addition, swapcache_high_wmark should be greater
than swapcache_low_wmark.
Signed-off-by: liubo <liubo254@huawei.com>
---
etmem/src/etmemd_src/etmemd_migrate.c | 2 +-
etmem/src/etmemd_src/etmemd_project.c | 20 ++++++++++++++------
2 files changed, 15 insertions(+), 7 deletions(-)
diff --git a/etmem/src/etmemd_src/etmemd_migrate.c b/etmem/src/etmemd_src/etmemd_migrate.c
index a5cce41..a143c5e 100644
--- a/etmem/src/etmemd_src/etmemd_migrate.c
+++ b/etmem/src/etmemd_src/etmemd_migrate.c
@@ -115,7 +115,7 @@ static bool check_should_reclaim_swapcache(const struct task_pid *tk_pid)
unsigned long swapcache_total;
int ret;
- if (proj->swapcache_high_wmark == 0) {
+ if (proj->swapcache_high_wmark == -1 || proj->swapcache_low_wmark == -1) {
return false;
}
diff --git a/etmem/src/etmemd_src/etmemd_project.c b/etmem/src/etmemd_src/etmemd_project.c
index 72d7335..e238e66 100644
--- a/etmem/src/etmemd_src/etmemd_project.c
+++ b/etmem/src/etmemd_src/etmemd_project.c
@@ -649,13 +649,13 @@ static int fill_project_sysmem_threshold(void *obj, void *val)
}
/* fill the project parameter: swapcache_low_wmark
- * swapcache_low_wmark: [0, 100]. */
+ * swapcache_low_wmark: (0, 100]. */
static int fill_project_swapcache_low_wmark(void *obj, void *val)
{
struct project *proj = (struct project *)obj;
int swapcache_low_wmark = parse_to_int(val);
- if (swapcache_low_wmark < 0 || swapcache_low_wmark > MAX_SWAPCACHE_WMARK_VALUE) {
+ if (swapcache_low_wmark <= 0 || swapcache_low_wmark > MAX_SWAPCACHE_WMARK_VALUE) {
etmemd_log(ETMEMD_LOG_ERR, "invaild project swapcache_low_wmark value %d, it must between 0 and 100.\n",
swapcache_low_wmark);
return -1;
@@ -672,7 +672,7 @@ static int fill_project_swapcache_high_wmark(void *obj, void *val)
struct project *proj = (struct project *)obj;
int swapcache_high_wmark = parse_to_int(val);
- if (swapcache_high_wmark < 0 || swapcache_high_wmark > MAX_SWAPCACHE_WMARK_VALUE) {
+ if (swapcache_high_wmark <= 0 || swapcache_high_wmark > MAX_SWAPCACHE_WMARK_VALUE) {
etmemd_log(ETMEMD_LOG_ERR, "invaild project swapcache_high_wmark value %d, it must between 0 and 100.\n",
swapcache_high_wmark);
return -1;
@@ -684,11 +684,17 @@ static int fill_project_swapcache_high_wmark(void *obj, void *val)
static bool check_swapcache_wmark_valid(struct project *proj)
{
- if (proj->swapcache_low_wmark > proj->swapcache_high_wmark) {
- return false;
+ if (proj->swapcache_high_wmark == -1 && proj->swapcache_low_wmark == -1) {
+ return true;
}
- return true;
+ if ((proj->swapcache_high_wmark > 0) &&
+ (proj->swapcache_low_wmark > 0) &&
+ (proj->swapcache_high_wmark > proj->swapcache_low_wmark)) {
+ return true;
+ }
+
+ return false;
}
static struct config_item g_project_config_items[] = {
@@ -759,6 +765,8 @@ enum opt_result etmemd_project_add(GKeyFile *config)
}
proj->sysmem_threshold = -1;
+ proj->swapcache_high_wmark = -1;
+ proj->swapcache_low_wmark = -1;
if (project_fill_by_conf(config, proj) != 0) {
etmemd_log(ETMEMD_LOG_ERR, "fill project from configuration file fail\n");
--
1.8.3.1

108
0070-etmem-update-README.md.patch Normal file
View File

@ -0,0 +1,108 @@
From 1ebeebf02a171d0029e70ee67270a8f7dab3e04e Mon Sep 17 00:00:00 2001
From: liubo <liubo254@huawei.com>
Date: Thu, 24 Feb 2022 01:13:17 +0000
Subject: [PATCH 20/33] etmem: update README.md.
Add the usage constraints of etmem,
and introduce some added configuration file parameters
Signed-off-by: liubo <liubo254@huawei.com>
---
README.md | 45 ++++++++++++++++++++++++++++++++++++++++-----
1 file changed, 40 insertions(+), 5 deletions(-)
diff --git a/README.md b/README.md
index 93631a1..49287f9 100644
--- a/README.md
+++ b/README.md
@@ -29,6 +29,30 @@ etmem内存分级扩展技术，通过DRAM+内存压缩/高性能存储新介质
$ make
+## 注意事项
+### 运行依赖
+etmem作为内存扩展工具，需要依赖于内核态的特性支持，为了可以识别内存访问情况和支持主动将内存写入swap分区来达到内存垂直扩展的需求，etmem在运行时需要插入etmem_scan和etmem_swap模块：
+
+```
+modprobe etmem_scan
+modprobe etmem_swap
+```
+openuler21.03、21.09、20.03 LTS SP2以及20.03 LTS SP3均支持etmem内存扩展相关特性，可以直接使用以上内核。
+
+### 权限限制
+运行etmem进程需要root权限，root用户具有系统最高权限，在使用root用户进行操作时，请严格按照操作指导进行操作，避免其他操作造成系统管理及安全风险。
+
+### 使用约束
+
+- etmem的客户端和服务端需要在同一个服务器上部署，不支持跨服务器通信的场景。
+- etmem仅支持扫描进程名小于或等于15个字符长度的目标进程。
+- 在使用AEP介质进行内存扩展的时候，依赖于系统可以正确识别AEP设备并将AEP设备初始化为numa node。并且配置文件中的vm_flags字段只能配置为ht。
+- 引擎私有命令仅针对对应引擎和引擎下的任务有效，比如cslide所支持的showhostpages和showtaskpages。
+- 第三方策略实现代码中，eng_mgt_func接口中的fd不能写入0xff和0xfe字。
+- 支持在一个工程内添加多个不同的第三方策略动态库，以配置文件中的eng_name来区分。
+- 禁止并发扫描同一个进程。未加载etmem_scan和etmem_swap ko时，禁止使用/proc/xxx/idle_pages和/proc/xxx/swap_pages文件
+
+
## 使用说明
### 启动etmemd进程
@@ -63,7 +87,14 @@ options：
在运行etmem进程之前，需要管理员预先规划哪些进程需要做内存扩展，将进程信息配置到etmem配置文件中，并配置内存扫描的周期、扫描次数、内存冷热阈值等信息。
-配置文件的示例文件在源码包中，放置在源码根目录的conf/example_conf.yaml，建议在使用时放置在/etc/etmem/目录下，示例内容为：
+配置文件的示例文件在源码包中，放置在/etc/etmem文件路径下，按照功能划分为3个示例文件，
+
+```
+/etc/etmem/cslide_conf.yaml
+/etc/etmem/slide_conf.yaml
+/etc/etmem/thirdparty_conf.yaml
+```
+示例内容分别为：
```
[project]
@@ -132,6 +163,9 @@ task_private_key=task_private_value
| loop | 内存扫描的循环次数 | 是 | 是 | 1~10 | loop=3 //扫描3次 |
| interval | 每次内存扫描的时间间隔 | 是 | 是 | 1~1200 | interval=5 //每次扫描之间间隔5s |
| sleep | 每个内存扫描+操作的大周期之间时间间隔 | 是 | 是 | 1~1200 | sleep=10 //每次大周期之间间隔10s |
+| sysmem_threshold| slide engine的配置项，系统内存换出阈值 | 否 | 是 | 0~100 | sysmem_threshold=50 //系统内存剩余量小于50%时，etmem才会触发内存换出|
+| swapcache_high_wmark| slide engine的配置项，swacache可以占用系统内存的比例，高水线 | 否 | 是 | 1~100 | swapcache_high_wmark=5 //swapcache内存占用量可以为系统内存的5%，超过该比例，etmem会触发swapcache回收<br> 注： swapcache_high_wmark需要大于swapcache_low_wmark|
+| swapcache_low_wmark| slide engine的配置项，swacache可以占用系统内存的比例，低水线 | 否 | 是 | [1~swapcache_high_wmark) | swapcache_low_wmark=3 //触发swapcache回收后，系统会将swapcache内存占用量回收到低于3%|
| [engine] | engine公用配置段起始标识 | 否 | 否 | NA | engine参数的开头标识，表示下面的参数直到另外的[xxx]或文件结尾为止的范围内均为engine section的参数 |
| project | 声明所在的project | 是 | 是 | 64个字以内的字符串 | 已经存在名字为test的project，则可以写为project=test |
| engine | 声明所在的engine | 是 | 是 | slide/cslide/thridparty | 声明使用的是slide或cslide或thirdparty策略 |
@@ -155,7 +189,8 @@ task_private_key=task_private_value
| anon_only | engine为cslide的task配置项，标识是否只扫描匿名页 | 否 | 是 | yes/no | anon_only=no //配置为yes时只扫描匿名页，配置为no时非匿名页也会扫描 |
| ign_host | engine为cslide的task配置项，标识是否忽略host上的页表扫描信息 | 否 | 是 | yes/no | ign_host=no //yes为忽略，no为不忽略 |
| task_private_key | engine为thirdparty的task配置项，预留给第三方策略的task解析私有参数的配置项，选配 | 否 | 否 | 根据第三方策略私有参数自行限制 | 根据第三方策略私有task参数自行配置 |
-
+| swap_threshold |slide engine的配置项，进程内存换出阈值 | 否 | 是 | 进程可用内存绝对值 | swap_threshold=10g //进程占用内存在低于10g时不会触发换出。<br>当前版本下，仅支持g/G作为内存绝对值单位。与sysmem_threshold配合使用，仅系统内存低于阈值时，进行白名单中进程阈值判断 |
+| swap_flag|slide engine的配置项，进程指定内存换出 | 否 | 是 | yes/no | swap_flag=yes//使能进程指定内存换出 |
### etmem project/engine/task对象的创建和删除
@@ -172,11 +207,11 @@ task_private_key=task_private_value
添加对象：
-etmem obj add -f /etc/example_config.yaml -s etmemd_socket
+etmem obj add -f /etc/etmem/slide_conf.yaml -s etmemd_socket
删除对象：
-etmem obj del -f /etc/example_config.yaml -s etmemd_socket
+etmem obj del -f /etc/etmem/slide_conf.yaml -s etmemd_socket
打印帮助：
@@ -491,4 +526,4 @@ etmem engine showhostpages -n proj_name -e cslide -s etmemd_socket
1. Fork本仓库
2. 新建个人分支
3. 提交代码
-4. 新建Pull Request
\ No newline at end of file
+4. 新建Pull Request
--
1.8.3.1

520
0071-etmem-add-code-of-testcase.patch Normal file
View File

@ -0,0 +1,520 @@
From 6847808d04c18a76db6bbf38ac6e421a5fac8b7c Mon Sep 17 00:00:00 2001
From: liubo <liubo254@huawei.com>
Date: Mon, 24 Jan 2022 03:50:17 +0800
Subject: [PATCH 21/33] etmem: add code of testcase
add code of testcase of etmem socket functions.
Signed-off-by: liubo <liubo254@huawei.com>
---
etmem/test/conf/conf_cslide/task.config | 16 +-
etmem/test/etmem_migrate_ops_llt/CMakeLists.txt | 54 ++--
.../etmem_migrate_ops_llt/etmem_migrate_ops_llt.c | 5 +-
.../test/etmem_socket_ops_llt_test/CMakeLists.txt | 26 ++
.../etmem_socket_ops_llt.c | 356 +++++++++++++++++++++
5 files changed, 419 insertions(+), 38 deletions(-)
create mode 100644 etmem/test/etmem_socket_ops_llt_test/CMakeLists.txt
create mode 100644 etmem/test/etmem_socket_ops_llt_test/etmem_socket_ops_llt.c
diff --git a/etmem/test/conf/conf_cslide/task.config b/etmem/test/conf/conf_cslide/task.config
index 336be39..9719cb6 100644
--- a/etmem/test/conf/conf_cslide/task.config
+++ b/etmem/test/conf/conf_cslide/task.config
@@ -1,9 +1,9 @@
-[task]
-project=test
-engine=cslide
-name=background1
-type=pid
-value=1
-vm_flags=ht
-anon_only=no
+[task]
+project=test
+engine=cslide
+name=background1
+type=pid
+value=1
+vm_flags=ht
+anon_only=no
ign_host=yes
\ No newline at end of file
diff --git a/etmem/test/etmem_migrate_ops_llt/CMakeLists.txt b/etmem/test/etmem_migrate_ops_llt/CMakeLists.txt
index a9487af..d998af7 100644
--- a/etmem/test/etmem_migrate_ops_llt/CMakeLists.txt
+++ b/etmem/test/etmem_migrate_ops_llt/CMakeLists.txt
@@ -1,27 +1,27 @@
-# /******************************************************************************
-# * Copyright (c) Huawei Technologies Co., Ltd. 2019-2021. All rights reserved.
-# * etmem is licensed under the Mulan PSL v2.
-# * You can use this software according to the terms and conditions of the Mulan PSL v2.
-# * You may obtain a copy of Mulan PSL v2 at:
-# * http://license.coscl.org.cn/MulanPSL2
-# * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
-# * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
-# * PURPOSE.
-# * See the Mulan PSL v2 for more details.
-# * Author: liubo
-# * Create: 2021-12-10
-# * Description: CMakefileList for etmem_migrate_ops_llt to compile
-# ******************************************************************************/
-
-project(etmem)
-
-INCLUDE_DIRECTORIES(../../inc/etmem_inc)
-INCLUDE_DIRECTORIES(../../inc/etmemd_inc)
-INCLUDE_DIRECTORIES(${GLIB2_INCLUDE_DIRS})
-
-SET(EXE etmem_migrate_ops_llt)
-
-add_executable(${EXE} etmem_migrate_ops_llt.c)
-
-set_target_properties(${EXE} PROPERTIES LINK_FLAGS "-Wl,--wrap,get_mem_from_proc_file")
-target_link_libraries(${EXE} cunit ${BUILD_DIR}/lib/libetmemd.so pthread dl rt boundscheck numa ${GLIB2_LIBRARIES})
+# /******************************************************************************
+# * Copyright (c) Huawei Technologies Co., Ltd. 2019-2021. All rights reserved.
+# * etmem is licensed under the Mulan PSL v2.
+# * You can use this software according to the terms and conditions of the Mulan PSL v2.
+# * You may obtain a copy of Mulan PSL v2 at:
+# * http://license.coscl.org.cn/MulanPSL2
+# * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+# * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+# * PURPOSE.
+# * See the Mulan PSL v2 for more details.
+# * Author: liubo
+# * Create: 2021-12-10
+# * Description: CMakefileList for etmem_migrate_ops_llt to compile
+# ******************************************************************************/
+
+project(etmem)
+
+INCLUDE_DIRECTORIES(../../inc/etmem_inc)
+INCLUDE_DIRECTORIES(../../inc/etmemd_inc)
+INCLUDE_DIRECTORIES(${GLIB2_INCLUDE_DIRS})
+
+SET(EXE etmem_migrate_ops_llt)
+
+add_executable(${EXE} etmem_migrate_ops_llt.c)
+
+set_target_properties(${EXE} PROPERTIES LINK_FLAGS "-Wl,--wrap,get_mem_from_proc_file")
+target_link_libraries(${EXE} cunit ${BUILD_DIR}/lib/libetmemd.so pthread dl rt boundscheck numa ${GLIB2_LIBRARIES})
diff --git a/etmem/test/etmem_migrate_ops_llt/etmem_migrate_ops_llt.c b/etmem/test/etmem_migrate_ops_llt/etmem_migrate_ops_llt.c
index 2758680..5c9b0d4 100644
--- a/etmem/test/etmem_migrate_ops_llt/etmem_migrate_ops_llt.c
+++ b/etmem/test/etmem_migrate_ops_llt/etmem_migrate_ops_llt.c
@@ -65,8 +65,7 @@ static struct memory_grade *get_memory_grade(void)
memory_grade = (struct memory_grade *)calloc(1, sizeof(struct memory_grade));
CU_ASSERT_PTR_NOT_NULL(memory_grade);
- while (page_refs != NULL)
- {
+ while (page_refs != NULL) {
if ((page_refs)->count >= WATER_LINE_TEMP) {
page_refs = add_page_refs_into_memory_grade(page_refs, &memory_grade->hot_pages);
continue;
@@ -104,7 +103,7 @@ static void test_etmem_migrate_ok(void)
memory_grade = get_memory_grade();
CU_ASSERT_PTR_NOT_NULL(memory_grade);
- CU_ASSERT_EQUAL(etmemd_grade_migrate("1", memory_grade), -1);
+ CU_ASSERT_EQUAL(etmemd_grade_migrate("1", memory_grade), 0);
clean_memory_grade_unexpected(&memory_grade);
CU_ASSERT_PTR_NULL(memory_grade);
diff --git a/etmem/test/etmem_socket_ops_llt_test/CMakeLists.txt b/etmem/test/etmem_socket_ops_llt_test/CMakeLists.txt
new file mode 100644
index 0000000..7cc5343
--- /dev/null
+++ b/etmem/test/etmem_socket_ops_llt_test/CMakeLists.txt
@@ -0,0 +1,26 @@
+# /******************************************************************************
+# * Copyright (c) Huawei Technologies Co., Ltd. 2019-2021. All rights reserved.
+# * etmem is licensed under the Mulan PSL v2.
+# * You can use this software according to the terms and conditions of the Mulan PSL v2.
+# * You may obtain a copy of Mulan PSL v2 at:
+# * http://license.coscl.org.cn/MulanPSL2
+# * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+# * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+# * PURPOSE.
+# * See the Mulan PSL v2 for more details.
+# * Author: liubo
+# * Create: 2021-12-10
+# * Description: CMakefileList for etmem_log_ops_llt to compile
+# ******************************************************************************/
+
+project(etmem)
+
+INCLUDE_DIRECTORIES(../../inc/etmem_inc)
+INCLUDE_DIRECTORIES(../../inc/etmemd_inc)
+INCLUDE_DIRECTORIES(${GLIB2_INCLUDE_DIRS})
+
+SET(EXE etmem_socket_ops_llt)
+
+add_executable(${EXE} etmem_socket_ops_llt.c)
+
+target_link_libraries(${EXE} cunit ${BUILD_DIR}/lib/libetmemd.so pthread dl rt boundscheck numa ${GLIB2_LIBRARIES})
diff --git a/etmem/test/etmem_socket_ops_llt_test/etmem_socket_ops_llt.c b/etmem/test/etmem_socket_ops_llt_test/etmem_socket_ops_llt.c
new file mode 100644
index 0000000..387ffd1
--- /dev/null
+++ b/etmem/test/etmem_socket_ops_llt_test/etmem_socket_ops_llt.c
@@ -0,0 +1,356 @@
+/******************************************************************************
+ * Copyright (c) Huawei Technologies Co., Ltd. 2019-2021. All rights reserved.
+ * etmem is licensed under the Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ * http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+ * PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * Author: liubo
+ * Create: 2021-08-14
+ * Description: This is a source file of the unit test for rpc functions in etmem.
+ ******************************************************************************/
+
+#include <sys/file.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <pthread.h>
+#include <unistd.h>
+
+#include <CUnit/Basic.h>
+#include <CUnit/Automated.h>
+#include <CUnit/Console.h>
+
+#include "etmem_common.h"
+#include "etmem_rpc.h"
+#include "etmemd_rpc.h"
+#include "securec.h"
+#include "etmem.h"
+
+#define SOCK_NAME_MAX_LEN 108
+#define RPC_SEND_FILE_MAX 512
+#define SLEEP_TIME_ONE_T_US 1000
+
+static char *get_length_str(unsigned int length)
+{
+ char *result = NULL;
+ unsigned char i = 'a';
+ unsigned int j;
+ result = (char *)calloc(length + 1, sizeof(char));
+ if (result == NULL) {
+ return NULL;
+ }
+
+ for (j = 0; j < length; j++) {
+ result[j] = i;
+ }
+
+ return result;
+}
+
+static void test_sock_name_error(void)
+{
+ char *name = NULL;
+ CU_ASSERT_EQUAL(etmemd_parse_sock_name(NULL), -1);
+ CU_ASSERT_EQUAL(etmemd_parse_sock_name(""), -1);
+ CU_ASSERT_EQUAL(etmemd_parse_sock_name("name"), 0);
+
+ name = get_length_str(SOCK_NAME_MAX_LEN - 1);
+ CU_ASSERT_PTR_NOT_NULL(name);
+ CU_ASSERT_EQUAL(etmemd_parse_sock_name(name), -1);
+ free(name);
+
+ name = get_length_str(SOCK_NAME_MAX_LEN);
+ CU_ASSERT_PTR_NOT_NULL(name);
+ CU_ASSERT_EQUAL(etmemd_parse_sock_name(name), -1);
+ free(name);
+
+ name = get_length_str(SOCK_NAME_MAX_LEN + 1);
+ CU_ASSERT_PTR_NOT_NULL(name);
+ CU_ASSERT_EQUAL(etmemd_parse_sock_name(name), -1);
+ free(name);
+}
+
+static void test_sock_name_ok(void)
+{
+ char *name = NULL;
+
+ CU_ASSERT_EQUAL(etmemd_parse_sock_name("name"), 0);
+ CU_ASSERT_EQUAL(etmemd_parse_sock_name("n"), 0);
+
+ name = get_length_str(SOCK_NAME_MAX_LEN - 2);
+ CU_ASSERT_PTR_NOT_NULL(name);
+ CU_ASSERT_EQUAL(etmemd_parse_sock_name(name), 0);
+ free(name);
+}
+
+void *etmemd_rpc_server_start(void *msg)
+{
+ char *socket_name = (char *)msg;
+ CU_ASSERT_EQUAL(etmemd_parse_sock_name(socket_name), -1);
+ etmemd_rpc_server();
+}
+
+void *etmemd_rpc_server_start_ok(void *msg)
+{
+ char *socket_name = (char *)msg;
+ CU_ASSERT_EQUAL(etmemd_parse_sock_name(socket_name), 0);
+ etmemd_rpc_server();
+}
+
+static struct mem_proj *alloc_proj(int cmd, char *proj_name,
+ char *file_name, char *sock_name)
+{
+ struct mem_proj *proj = NULL;
+ proj = (struct mem_proj *)calloc(1, sizeof(struct mem_proj));
+ CU_ASSERT_PTR_NOT_NULL(proj);
+
+ proj->cmd = cmd;
+ proj->file_name = file_name;
+ proj->proj_name = proj_name;
+ proj->sock_name = sock_name;
+
+ return proj;
+}
+
+static int etmem_socket_client(int cmd, char *proj_name,
+ char *file_name, char *sock_name)
+{
+ int ret;
+ struct mem_proj *proj = NULL;
+ proj = alloc_proj(cmd, proj_name, file_name, sock_name);
+ ret = etmem_rpc_client(proj);
+ free(proj);
+ if (ret == 0) {
+ return 0;
+ }
+ return -1;
+}
+
+static void etmem_pro_add_error(void)
+{
+ char *file_name = NULL;
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_ADD, NULL, NULL, ""), -1);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_ADD, NULL, "", ""), -1);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_ADD, NULL, "file_name", ""), -1);
+ file_name = get_length_str(RPC_SEND_FILE_MAX);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_ADD, NULL, file_name, ""), -1);
+ free(file_name);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_ADD, NULL, "file_name", "sock_name"), -1);
+
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_ADD, "", NULL, ""), -1);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_ADD, "", "", ""), -1);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_ADD, "", "file_name", ""), -1);
+ file_name = get_length_str(RPC_SEND_FILE_MAX);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_ADD, "", file_name, ""), -1);
+ free(file_name);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_ADD, "", "file_name", "sock_name"), -1);
+
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_ADD, "test", NULL, ""), -1);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_ADD, "test", "", ""), -1);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_ADD, "test", "file_name", ""), -1);
+ file_name = get_length_str(RPC_SEND_FILE_MAX);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_ADD, "test", file_name, ""), -1);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_ADD, "test", "file_name", "sock_name"), -1);
+ free(file_name);
+}
+
+static void etmem_pro_del_error(void)
+{
+ char *file_name = NULL;
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_DEL, NULL, NULL, ""), -1);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_DEL, NULL, "", ""), -1);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_DEL, NULL, "file_name", ""), -1);
+ file_name = get_length_str(RPC_SEND_FILE_MAX);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_DEL, NULL, file_name, ""), -1);
+ free(file_name);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_DEL, NULL, "file_name", "sock_name"), -1);
+
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_DEL, "", NULL, ""), -1);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_DEL, "", "", ""), -1);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_DEL, "", "file_name", ""), -1);
+ file_name = get_length_str(RPC_SEND_FILE_MAX);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_DEL, "", file_name, ""), -1);
+ free(file_name);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_DEL, "", "file_name", "sock_name"), -1);
+
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_DEL, "test", NULL, ""), -1);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_DEL, "test", "", ""), -1);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_DEL, "test", "file_name", ""), -1);
+ file_name = get_length_str(RPC_SEND_FILE_MAX);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_DEL, "test", file_name, ""), -1);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_DEL, "test", "file_name", "sock_name"), -1);
+ free(file_name);
+}
+
+static void etmem_pro_start_error(void)
+{
+ char *file_name = NULL;
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_START, NULL, NULL, ""), -1);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_START, NULL, "", ""), -1);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_START, NULL, "file_name", ""), -1);
+ file_name = get_length_str(RPC_SEND_FILE_MAX);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_START, NULL, file_name, ""), -1);
+ free(file_name);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_START, NULL, "file_name", "sock_name"), -1);
+
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_START, "", NULL, ""), -1);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_START, "", "", ""), -1);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_START, "", "file_name", ""), -1);
+ file_name = get_length_str(RPC_SEND_FILE_MAX);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_START, "", file_name, ""), -1);
+ free(file_name);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_START, "", "file_name", "sock_name"), -1);
+
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_START, "test", NULL, ""), -1);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_START, "test", "", ""), -1);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_START, "test", "file_name", ""), -1);
+ file_name = get_length_str(RPC_SEND_FILE_MAX);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_START, "test", file_name, ""), -1);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_START, "test", "file_name", "sock_name"), -1);
+ free(file_name);
+}
+
+static void etmem_pro_stop_error(void)
+{
+ char *file_name = NULL;
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_STOP, NULL, NULL, ""), -1);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_STOP, NULL, "", ""), -1);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_STOP, NULL, "file_name", ""), -1);
+ file_name = get_length_str(RPC_SEND_FILE_MAX);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_STOP, NULL, file_name, ""), -1);
+ free(file_name);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_STOP, NULL, "file_name", "sock_name"), -1);
+
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_STOP, "", NULL, ""), -1);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_STOP, "", "", ""), -1);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_STOP, "", "file_name", ""), -1);
+ file_name = get_length_str(RPC_SEND_FILE_MAX);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_STOP, "", file_name, ""), -1);
+ free(file_name);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_STOP, "", "file_name", "sock_name"), -1);
+
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_STOP, "test", NULL, ""), -1);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_STOP, "test", "", ""), -1);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_STOP, "test", "file_name", ""), -1);
+ file_name = get_length_str(RPC_SEND_FILE_MAX);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_STOP, "test", file_name, ""), -1);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_STOP, "test", "file_name", "sock_name"), -1);
+ free(file_name);
+}
+
+static void test_socket_client_error(void)
+{
+ struct mem_proj *proj = NULL;
+ char *project_name = NULL;
+ char *file_name = NULL;
+ char *sock_name = NULL;
+ char *msg = "etmem_error_sock";
+
+ pthread_t etmem_socket_test;
+
+ CU_ASSERT_EQUAL(pthread_create(&etmem_socket_test, NULL, etmemd_rpc_server_start, NULL), EOK);
+ CU_ASSERT_EQUAL(pthread_create(&etmem_socket_test, NULL,
+ etmemd_rpc_server_start_ok, (void *)msg), EOK);
+ usleep(SLEEP_TIME_ONE_T_US);
+ etmem_pro_add_error();
+ etmem_pro_del_error();
+ etmem_pro_start_error();
+ etmem_pro_stop_error();
+
+ etmemd_handle_signal();
+}
+
+static void test_socket_client_ok(void)
+{
+ struct mem_proj *proj = NULL;
+ char *project_name = NULL;
+ char *file_name = NULL;
+ char *sock_name = NULL;
+ char *msg = "etmem_ok_sock";
+
+ pthread_t etmem_socket_test_ok;
+
+ CU_ASSERT_EQUAL(pthread_create(&etmem_socket_test_ok, NULL,
+ etmemd_rpc_server_start_ok, (void *)msg), EOK);
+ usleep(SLEEP_TIME_ONE_T_US);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_ADD, "test",
+ "../conf/conf_slide/config_file", msg), 0);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_SHOW, "test",
+ "../conf/conf_slide/config_file", msg), 0);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_START, "test",
+ "../conf/conf_slide/config_file", msg), 0);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_STOP, "test",
+ "../conf/conf_slide/config_file", msg), 0);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_DEL, "test",
+ "../conf/conf_slide/config_file", msg), 0);
+
+ etmemd_handle_signal();
+}
+
+typedef enum {
+ CUNIT_SCREEN = 0,
+ CUNIT_XMLFILE,
+ CUNIT_CONSOLE
+} cu_run_mode;
+
+int main(int argc, const char **argv)
+{
+ CU_pSuite suite;
+ CU_pTest pTest;
+ unsigned int num_failures;
+ cu_run_mode cunit_mode = CUNIT_SCREEN;
+ int error_num;
+
+ if (argc > 1) {
+ cunit_mode = atoi(argv[1]);
+ }
+
+ if (CU_initialize_registry() != CUE_SUCCESS) {
+ return -CU_get_error();
+ }
+
+ suite = CU_add_suite("etmem_socket_ops", NULL, NULL);
+ if (suite == NULL) {
+ goto ERROR;
+ }
+
+ if (CU_ADD_TEST(suite, test_sock_name_error) == NULL ||
+ CU_ADD_TEST(suite, test_sock_name_ok) == NULL ||
+ CU_ADD_TEST(suite, test_socket_client_error) == NULL ||
+ CU_ADD_TEST(suite, test_socket_client_ok) == NULL) {
+ printf("CU_ADD_TEST fail. \n");
+ goto ERROR;
+ }
+
+ switch (cunit_mode) {
+ case CUNIT_SCREEN:
+ CU_basic_set_mode(CU_BRM_VERBOSE);
+ CU_basic_run_tests();
+ break;
+ case CUNIT_XMLFILE:
+ CU_set_output_filename("etmemd_rpc.c");
+ CU_automated_run_tests();
+ break;
+ case CUNIT_CONSOLE:
+ CU_console_run_tests();
+ break;
+ default:
+ printf("not support cunit mode, only support: "
+ "0 for CUNIT_SCREEN, 1 for CUNIT_XMLFILE, 2 for CUNIT_CONSOLE\n");
+ goto ERROR;
+ }
+
+ num_failures = CU_get_number_of_failures();
+ CU_cleanup_registry();
+ return num_failures;
+
+ERROR:
+ error_num = CU_get_error();
+ CU_cleanup_registry();
+ return -error_num;
+}
--
1.8.3.1

1040
0072-etmem-add-code-of-testcase.patch Normal file
View File

File diff suppressed because it is too large Load Diff

308
0073-etmem-add-testcode-script.patch Normal file
View File

@ -0,0 +1,308 @@
From 2d15999e02c34c2580bb8744a143806e4391338e Mon Sep 17 00:00:00 2001
From: liubo <liubo254@huawei.com>
Date: Mon, 24 Jan 2022 07:52:02 +0800
Subject: [PATCH 23/33] etmem: add testcode script
add test.sh, the testcode compile and run script, for etmem.
Signed-off-by: liubo <liubo254@huawei.com>
---
etmem/test/test.sh | 286 +++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 286 insertions(+)
create mode 100644 etmem/test/test.sh
diff --git a/etmem/test/test.sh b/etmem/test/test.sh
new file mode 100644
index 0000000..55a8cd9
--- /dev/null
+++ b/etmem/test/test.sh
@@ -0,0 +1,286 @@
+#!/bin/bash
+
+run_test_exit_value=0
+usage()
+{
+ echo "Usage: sh test.sh [OPTIONS]"
+ echo "Use test.sh to control test operation"
+ echo
+ echo "Misc:"
+ echo " -h, --help Print this help, then exit"
+ echo
+ echo "Compile Options:"
+ echo " -m, --cmake <option> use cmake genenate Makefile, eg: -m(default), -mcoverage, -masan, --cmake, --cmake=coverage"
+ echo " -c, --compile Enable compile"
+ echo " -e, --empty Enable compile empty(make clean)"
+ echo
+ echo "TestRun Options"
+ echo " -r, --run <option> Run all test, eg: -r, -rscreen(default), -rxml, --run, --run=screen, --run=xml"
+ echo " -s, --specify FILE Only Run specify test executable FILE, eg: -smemory_test, --specify=memory_test"
+ echo
+ echo "Coverage Options"
+ echo " -t, --cover-report <option> Enable coverage report. eg: -t, -thtml(default), -ttxt, --cover-report, --cover-report=html, --cover-report=txt"
+ echo " -f, --cover-file FILE Specified FILE coverage report, eg: -fmemory.c, --cover-file=memory.c"
+ echo
+}
+
+ARGS=`getopt -o "hcer::m::t::s:f:" -l "help,cmake::,empty,cover-report::,run::,specify:,cover-file:" -n "test.sh" -- "$@"`
+if [ $? != 0 ]; then
+ usage
+ exit 1
+fi
+
+eval set -- "${ARGS}"
+
+if [ x"$ARGS" = x" --" ]; then
+ # set default value
+ COMPILE_ENABLE=no
+ COVERAGE_ENABLE=no
+ ASAN_ENABLE=no
+ CLEAN_ENABLE=no
+ RUN_TEST=yes
+ RUN_MODE=screen # value: screen or xml
+ COVER_REPORT_ENABLE=no
+fi
+
+while true; do
+ case "${1}" in
+ -h|--help)
+ usage; exit 0;;
+ -m|--cmake)
+ CMAKE_ENABLE=yes
+ case "$2" in
+ "") shift 2;;
+ coverage) COVERAGE_ENABLE=yes; shift 2;;
+ asan) ASAN_ENABLE=yes; shift 2;;
+ *) echo -e "\033[;31mError\033[0m param: $2"; exit 1;;
+ esac;;
+ -c|--compile)
+ COMPILE_ENABLE=yes
+ shift;;
+ -e|--empty)
+ CLEAN_ENABLE=yes
+ shift;;
+ -r|--run)
+ RUN_TEST=yes
+ case "$2" in
+ "") RUN_MODE=screen; shift 2;;
+ screen) RUN_MODE=screen; shift 2;;
+ xml) RUN_MODE=xml; shift 2;;
+ *)echo -e "\033[;31mError\033[0m param: $2"; exit 1;;
+ esac;;
+ -t|--cover-report)
+ COVER_REPORT_ENABLE=yes
+ case "$2" in
+ "") COVER_STYLE=html;shift 2;;
+ html) COVER_STYLE=html;shift 2;;
+ txt) COVER_STYLE=txt;shift 2;;
+ *)echo -e "\033[;31mError\033[0m param: $2"; exit 1;;
+ esac;;
+ -s|--specify)
+ SPECIFY=$2
+ shift 2;;
+ -f|--cover-file)
+ COVER_FILE=$2
+ shift 2;;
+ --)
+ shift; break;;
+ esac
+done
+
+function test_clean()
+{
+ echo ------------------ clean begin -----------------
+ rm build -rf
+ rm ../build -rf
+ echo ------------------ clean end ------------------
+}
+
+function test_cmake()
+{
+ local CMAKE_OPTION="-DCMAKE_BUILD_TYPE=Debug"
+ CMAKE_OPTION="${CMAKE_OPTION} -DCONFIG_DEBUG=1"
+
+ echo --------------- cmake begin --------------------
+ if [ x"${COVERAGE_ENABLE}" = x"yes" ]; then
+ CMAKE_OPTION="${CMAKE_OPTION} -DCOVERAGE_ENABLE=1"
+ fi
+
+ if [ x"${ASAN_ENABLE}" = x"yes" ]; then
+ CMAKE_OPTION="${CMAKE_OPTION} -DASAN_ENABLE=1"
+ fi
+
+ if [ ! -d build ]; then
+ mkdir build
+ fi
+
+ cd build
+ cmake .. ${CMAKE_OPTION}
+ cd -
+ echo --------------- cmake end --------------------
+ echo
+}
+
+function test_compile()
+{
+ echo --------------- compile begin --------------------
+ if [ -d build ]; then
+ cd build
+ make
+ cd -
+ else
+ echo -e "<build> directory \033[;31mnot exist\033[0m, pls check!"
+ fi
+ echo --------------- compile end --------------------
+ echo
+}
+
+function test_run_all()
+{
+ echo --------------- run test begin --------------------
+ if [ ! -d build ]; then
+ echo -e "<build> directory \033[;31mnot exist\033[0m, pls check!"
+ exit 1
+ fi
+
+ cd build
+ \cp -rf bin/etmem /usr/bin/
+ \cp -rf bin/etmem /usr/bin/
+ if [ x"${RUN_MODE}" = x"screen" ]; then
+ RUN_MODE=0
+ elif [ x"${RUN_MODE}" = x"xml" ]; then
+ RUN_MODE=1
+ elif [ x"${RUN_MODE}" = x"" ]; then
+ RUN_MODE=0
+ else
+ echo -e "\033[;31mnot suport\033[0m run mode <${RUN_MODE}>"
+ usage
+ cd -
+ exit 1
+ fi
+
+ if [ x"${SPECIFY}" = x"" ]; then
+ SPECIFY=`find -name "*_llt"` # run all test
+ else
+ SPECIFY=`find -name "${SPECIFY}"` # run one test
+ fi
+
+ TEST_LOG=test_result.log
+ >$TEST_LOG
+
+ SLIDE_LOG=test_slide.log
+ >$SLIDE_LOG
+
+ for TEST in $SPECIFY; do
+ echo $TEST
+ $TEST $RUN_MODE
+ if [ $? != 0 ]; then
+ run_test_exit_value=1
+ echo failed $TEST >> $TEST_LOG
+ else
+ echo passed $TEST >> $TEST_LOG
+ fi
+ done
+
+ echo
+ echo '#################test result begin##################'
+ sed 's/passed/\x1b[32m&\x1b[0m/g; s/^failed/\x1b[31m&\x1b[0m/g' $TEST_LOG
+ echo '#################test result end ##################'
+ echo
+ echo --------------- run test end --------------------
+ echo
+ cd -
+ if [ ${run_test_exit_value} != 0 ]; then
+ exit 1
+ fi
+}
+
+function geneate_coverage()
+{
+ local target_dir=$(dirname `pwd`)
+
+ echo --------------- geneate coverage begin --------------------
+ if [ x"${COVER_STYLE}" = x"txt" ]; then
+ if [ ! -d ${target_dir}/build/coverage/txt ]; then
+ mkdir -p ${target_dir}/build/coverage/txt
+ fi
+
+ GCDAS=`find ${target_dir} -name "${COVER_FILE}.gcda"`
+ echo ${COVER_FILE}.gcda
+ if [ x"$GCDAS" = x"" ]; then
+ echo -e "\033[;31mnot find\033[0m ${COVER_FILE}.gcda"
+ echo
+ cd -
+ exit 1
+ fi
+
+ cd ${target_dir}/build/coverage/txt
+ for GCDA in $GCDAS; do
+ gcov $GCDA
+ done
+ cd -
+
+ find ${target_dir} -name "*.h.gcov" | xargs rm -f
+ echo '###########################################'
+ find ${target_dir} -name "${COVER_FILE}.gcov"
+ echo '###########################################'
+ elif [ x"${COVER_STYLE}" = x"html" ]; then
+ if [ -d ${target_dir}/build/coverage/html ]; then
+ rm -rf ${target_dir}/build/coverage/html
+ fi
+ mkdir -p ${target_dir}/build/coverage/html
+ if [ x"${COVER_FILE}" = x"" ]; then
+ LCOV_CMD="-d ${target_dir}"
+ else
+ GCDAS=`find ${target_dir} -name "${COVER_FILE}.gcda"`
+ if [ $? != 0 ]; then
+ echo -e "\033[;31mnot find\033[0m ${COVER_FILE}.gcda"
+ exit 1
+ fi
+
+ for GCDA in ${GCDAS}; do
+ TMP_STR=" -d ${GCDA}";
+ LCOV_CMD="${LCOV_CMD} ${TMP_STR}";
+ done
+ fi
+
+ lcov -c ${LCOV_CMD} -b $(dirname $(pwd)) --no-external --exclude '*_llt.c' --exclude '*my_engine.c' --exclude '*test_common.c' --exclude '*etmemd_file.h' -o ${target_dir}/build/coverage/html/coverage.info --rc lcov_branch_coverage=1 --ignore-errors gcov --ignore-errors source --ignore-errors graph
+ if [ $? != 0 ]; then
+ echo -e "lcov generate coverage.info \033[;31mfail\033[0m."
+ exit 1
+ fi
+
+ genhtml ${target_dir}/build/coverage/html/coverage.info -o ${target_dir}/build/coverage/html --branch-coverage --rc lcov_branch_coverage=1 -s --legend --ignore-errors source
+ if [ $? != 0 ]; then
+ echo -e "genhtml \033[;31mfail\033[m."
+ exit 1
+ fi
+ chmod 755 -R ${target_dir}/build/coverage/html
+ fi
+ echo --------------- geneate coverage end --------------------
+}
+
+start_seconds=$(date --date="`date +'%Y-%m-%d %H:%M:%S'`" +%s)
+
+if [ x"${CLEAN_ENABLE}" = x"yes" ]; then
+ test_clean
+fi
+
+if [ x"${CMAKE_ENABLE}" = x"yes" ]; then
+ test_cmake
+fi
+
+if [ x"${COMPILE_ENABLE}" = x"yes" ]; then
+ test_compile
+fi
+
+if [ x"${RUN_TEST}" = x"yes" ]; then
+ test_run_all
+fi
+
+if [ x"${COVER_REPORT_ENABLE}" = x"yes" ]; then
+ geneate_coverage
+fi
+
+end_seconds=$(date --date="`date +'%Y-%m-%d %H:%M:%S'`" +%s)
+echo -e "\033[;36muse seconds: $((end_seconds-start_seconds))\033[0m"
--
1.8.3.1

2375
0074-etmem-add-code-of-testcase.patch Normal file
View File

File diff suppressed because it is too large Load Diff

378
0075-etmem-testcode-adaptation.patch Normal file
View File

@ -0,0 +1,378 @@
From 4a70847689d4afd36368cc14153e152bd13018f4 Mon Sep 17 00:00:00 2001
From: liubo <liubo254@huawei.com>
Date: Mon, 7 Mar 2022 20:18:06 +0800
Subject: [PATCH 25/33] etmem: testcode adaptation
Adapt the etmem low level testcode so that
it can be used normally in openeuler.
Fix some error in test code.
Signed-off-by: liubo <liubo254@huawei.com>
---
etmem/test/CMakeLists.txt | 4 +++-
etmem/test/common/test_common.c | 1 +
etmem/test/common/test_common.h | 1 +
etmem/test/conf/conf_cslide/proj.config | 3 ++-
etmem/test/conf/conf_slide/config_file | 1 +
.../etmem_common_func_llt_test/etmem_common_func_llt.c | 4 ++--
etmem/test/etmem_cslide_ops_llt_test/CMakeLists.txt | 2 +-
etmem/test/etmem_cslide_ops_llt_test/mem_access.c | 2 +-
.../etmem_project_ops_llt_test/etmem_project_ops_llt.c | 4 ++--
etmem/test/etmem_scan_ops_export_llt_test/CMakeLists.txt | 2 +-
etmem/test/etmem_scan_ops_llt_test/CMakeLists.txt | 2 +-
etmem/test/etmem_scan_ops_llt_test/etmem_scan_ops_llt.c | 16 ++++++++++++++--
.../test/etmem_slide_ops_llt_test/etmem_slide_ops_llt.c | 9 ---------
etmem/test/etmem_slide_ops_llt_test/test_slide_ops.sh | 0
etmem/test/etmem_socket_ops_llt_test/CMakeLists.txt | 2 +-
.../etmem_thirdparty_ops_llt.c | 8 ++++----
etmem/test/etmem_thirdparty_ops_llt_test/my_engine.c | 1 +
etmem/test/etmem_threadpool_ops_llt_test/CMakeLists.txt | 2 +-
.../etmem_threadpool_ops_llt.c | 10 +++++++++-
etmem/test/etmem_timer_ops_llt_test/CMakeLists.txt | 2 +-
20 files changed, 47 insertions(+), 29 deletions(-)
mode change 100644 => 100755 etmem/test/etmem_slide_ops_llt_test/test_slide_ops.sh
diff --git a/etmem/test/CMakeLists.txt b/etmem/test/CMakeLists.txt
index 3cc9bf6..a380e98 100644
--- a/etmem/test/CMakeLists.txt
+++ b/etmem/test/CMakeLists.txt
@@ -60,6 +60,7 @@ set(ETMEMD_CSLIDE_DEP
${ETMEMD_SRC_DIR}/etmemd_log.c
${ETMEMD_SRC_DIR}/etmemd_project.c
${ETMEMD_SRC_DIR}/etmemd_engine.c
+ ${ETMEMD_SRC_DIR}/etmemd_memdcd.c
${ETMEMD_SRC_DIR}/etmemd_slide.c
${ETMEMD_SRC_DIR}/etmemd_thirdparty.c
${ETMEMD_SRC_DIR}/etmemd_task.c
@@ -67,7 +68,8 @@ set(ETMEMD_CSLIDE_DEP
${ETMEMD_SRC_DIR}/etmemd_threadpool.c
${ETMEMD_SRC_DIR}/etmemd_threadtimer.c
${ETMEMD_SRC_DIR}/etmemd_pool_adapter.c
- ${ETMEMD_SRC_DIR}/etmemd_migrate.c)
+ ${ETMEMD_SRC_DIR}/etmemd_migrate.c
+ ${ETMEMD_SRC_DIR}/etmemd_damon.c)
set(TEST_COMMON_SRC
${TEST_COMMON_DIR}/test_common.c)
diff --git a/etmem/test/common/test_common.c b/etmem/test/common/test_common.c
index 4bd3fc3..db3b843 100644
--- a/etmem/test/common/test_common.c
+++ b/etmem/test/common/test_common.c
@@ -51,6 +51,7 @@ void construct_proj_file(struct proj_test_param *param)
file = fopen(param->file_name, "w+");
CU_ASSERT_PTR_NOT_NULL(file);
CU_ASSERT_NOT_EQUAL(fprintf(file, "[project]\n"), -1);
+ CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_SCAN_TYPE, "page"), -1);
if (param->proj_name != NULL) {
CU_ASSERT_NOT_EQUAL(fprintf(file, CONFIG_NAME, param->proj_name), -1);
}
diff --git a/etmem/test/common/test_common.h b/etmem/test/common/test_common.h
index 1ba20c7..2a42f78 100644
--- a/etmem/test/common/test_common.h
+++ b/etmem/test/common/test_common.h
@@ -21,6 +21,7 @@
#include "etmemd_project.h"
#define CONFIG_NAME "name=%s\n"
+#define CONFIG_SCAN_TYPE "scan_type=%s\n"
#define CONFIG_INTERVAL "interval=%s\n"
#define CONFIG_LOOP "loop=%s\n"
#define CONFIG_SLEEP "sleep=%s\n"
diff --git a/etmem/test/conf/conf_cslide/proj.config b/etmem/test/conf/conf_cslide/proj.config
index 1174df3..ca002ee 100644
--- a/etmem/test/conf/conf_cslide/proj.config
+++ b/etmem/test/conf/conf_cslide/proj.config
@@ -1,5 +1,6 @@
[project]
name=test
+scan_type=page
loop=3
interval=1
-sleep=1
\ No newline at end of file
+sleep=1
diff --git a/etmem/test/conf/conf_slide/config_file b/etmem/test/conf/conf_slide/config_file
index 5d9f965..b7eaae9 100644
--- a/etmem/test/conf/conf_slide/config_file
+++ b/etmem/test/conf/conf_slide/config_file
@@ -1,5 +1,6 @@
[project]
name=test
+scan_type=page
loop=1
interval=1
sleep=1
diff --git a/etmem/test/etmem_common_func_llt_test/etmem_common_func_llt.c b/etmem/test/etmem_common_func_llt_test/etmem_common_func_llt.c
index 1ba6299..3700baa 100644
--- a/etmem/test/etmem_common_func_llt_test/etmem_common_func_llt.c
+++ b/etmem/test/etmem_common_func_llt_test/etmem_common_func_llt.c
@@ -138,11 +138,11 @@ static void test_parse_cmdline_ok(void)
char *cmd_ok[] = {"./etmemd", "-l", "0", "-s", "cmd_ok"};
char *cmd_only_sock[] = {"./etmemd", "-s", "cmd_only_sock"};
- CU_ASSERT_EQUAL(etmemd_parse_cmdline(sizeof(cmd) / sizeof(cmd[0]), cmd, &is_help), 0);
+ CU_ASSERT_EQUAL(etmemd_parse_cmdline(sizeof(cmd_ok) / sizeof(cmd_ok[0]), cmd_ok, &is_help), 0);
etmemd_sock_name_free();
clean_flags(&is_help);
- CU_ASSERT_EQUAL(etmemd_parse_cmdline(sizeof(cmd_ok) / sizeof(cmd_ok[0]), cmd_ok, &is_help), 0);
+ CU_ASSERT_EQUAL(etmemd_parse_cmdline(sizeof(cmd) / sizeof(cmd[0]), cmd, &is_help), 0);
clean_flags(&is_help);
CU_ASSERT_EQUAL(etmemd_parse_cmdline(sizeof(cmd_h) / sizeof(cmd_h[0]), cmd_h, &is_help), 0);
diff --git a/etmem/test/etmem_cslide_ops_llt_test/CMakeLists.txt b/etmem/test/etmem_cslide_ops_llt_test/CMakeLists.txt
index 6ff709b..dce5a60 100644
--- a/etmem/test/etmem_cslide_ops_llt_test/CMakeLists.txt
+++ b/etmem/test/etmem_cslide_ops_llt_test/CMakeLists.txt
@@ -26,5 +26,5 @@ SET(EXE etmem_cslide_ops_llt)
add_executable(${EXE} etmem_cslide_ops_llt.c)
add_executable(mem_access mem_access.c)
-target_link_libraries(${EXE} cunit ${BUILD_DIR}/lib/libcslide.so ${BUILD_DIR}/lib/libtest.so pthread dl rt boundscheck numa ${GLIB2_LIBRARIES})
+target_link_libraries(${EXE} cunit ${BUILD_DIR}/lib/libcslide_dep.so ${BUILD_DIR}/lib/libtest.so pthread dl rt boundscheck numa ${GLIB2_LIBRARIES})
target_link_libraries(mem_access numa)
diff --git a/etmem/test/etmem_cslide_ops_llt_test/mem_access.c b/etmem/test/etmem_cslide_ops_llt_test/mem_access.c
index 56ad47e..a64d865 100644
--- a/etmem/test/etmem_cslide_ops_llt_test/mem_access.c
+++ b/etmem/test/etmem_cslide_ops_llt_test/mem_access.c
@@ -57,7 +57,7 @@ int main(int argc, char **argv)
if (argc > 3) {
dst_node = atoi(argv[1]);
- len = (long long)atoi(argv[2] << BYTE_TO_MB_SHIFT);
+ len = (long long)atoi(argv[2]) << BYTE_TO_MB_SHIFT;
is_busy = atoi(argv[3]);
} else {
printf("%s node size(MB) is busy\n", argv[0]);
diff --git a/etmem/test/etmem_project_ops_llt_test/etmem_project_ops_llt.c b/etmem/test/etmem_project_ops_llt_test/etmem_project_ops_llt.c
index 65c1fc6..8392402 100644
--- a/etmem/test/etmem_project_ops_llt_test/etmem_project_ops_llt.c
+++ b/etmem/test/etmem_project_ops_llt_test/etmem_project_ops_llt.c
@@ -417,7 +417,7 @@ static void add_project_once(void)
etmem_pro_add_swapcache_mark_ok();
init_proj_param(&param);
- CU_ASSERT_EQUAL(etmemd_project_show(NULL, 0), OPT_PRO_NOEXIST);
+ CU_ASSERT_EQUAL(etmemd_project_show(NULL, 0), OPT_SUCCESS);
config = construct_proj_config(&param);
CU_ASSERT_EQUAL(etmemd_project_add(config), OPT_SUCCESS);
@@ -429,7 +429,7 @@ static void add_project_once(void)
CU_ASSERT_EQUAL(etmemd_project_remove(config), OPT_SUCCESS);
destroy_proj_config(config);
- CU_ASSERT_EQUAL(etmemd_project_show("noexist", 0), OPT_PRO_NOEXIST);
+ CU_ASSERT_EQUAL(etmemd_project_show("noexist", 0), OPT_SUCCESS);
}
static int add_project_multiple(int proj_add_num)
diff --git a/etmem/test/etmem_scan_ops_export_llt_test/CMakeLists.txt b/etmem/test/etmem_scan_ops_export_llt_test/CMakeLists.txt
index be68154..587d621 100644
--- a/etmem/test/etmem_scan_ops_export_llt_test/CMakeLists.txt
+++ b/etmem/test/etmem_scan_ops_export_llt_test/CMakeLists.txt
@@ -23,4 +23,4 @@ SET(EXE etmem_scan_ops_export_llt)
add_executable(${EXE} etmem_scan_ops_export_llt.c)
-target_link_libraries(${EXE} cunit ${BUILD_DIR}/lib/libetmemd.so pthread dl rt libboundscheck numa ${GLIB2_LIBRARIES})
+target_link_libraries(${EXE} cunit ${BUILD_DIR}/lib/libetmemd.so pthread dl rt boundscheck numa ${GLIB2_LIBRARIES})
diff --git a/etmem/test/etmem_scan_ops_llt_test/CMakeLists.txt b/etmem/test/etmem_scan_ops_llt_test/CMakeLists.txt
index b5378b8..df50f80 100644
--- a/etmem/test/etmem_scan_ops_llt_test/CMakeLists.txt
+++ b/etmem/test/etmem_scan_ops_llt_test/CMakeLists.txt
@@ -23,4 +23,4 @@ SET(EXE etmem_scan_ops_llt)
add_executable(${EXE} etmem_scan_ops_llt.c)
-target_link_libraries(${EXE} cunit ${BUILD_DIR}/lib/libetmemd.so pthread dl rt libboundscheck numa ${GLIB2_LIBRARIES})
+target_link_libraries(${EXE} cunit ${BUILD_DIR}/lib/libetmemd.so pthread dl rt boundscheck numa ${GLIB2_LIBRARIES})
diff --git a/etmem/test/etmem_scan_ops_llt_test/etmem_scan_ops_llt.c b/etmem/test/etmem_scan_ops_llt_test/etmem_scan_ops_llt.c
index 84fcf69..cb1ccbc 100644
--- a/etmem/test/etmem_scan_ops_llt_test/etmem_scan_ops_llt.c
+++ b/etmem/test/etmem_scan_ops_llt_test/etmem_scan_ops_llt.c
@@ -42,12 +42,18 @@ static struct task *alloc_tk(int loop, int sleep)
struct task *tk = NULL;
struct project *proj = NULL;
struct engine *eng = NULL;
+ struct page_scan *page_scan = NULL;
+
+ page_scan = (struct page_scan *)calloc(1, sizeof(struct page_scan));
+ CU_ASSERT_PTR_NOT_NULL(page_scan);
proj = (struct project *)calloc(1, sizeof(struct project));
CU_ASSERT_PTR_NOT_NULL(proj);
- proj->loop = loop;
- proj->sleep = sleep;
+ proj->scan_param = page_scan;
+ proj->type = PAGE_SCAN;
+ page_scan->loop = loop;
+ page_scan->sleep = sleep;
tk = (struct task *)calloc(1, sizeof(struct task));
CU_ASSERT_PTR_NOT_NULL(tk);
@@ -272,6 +278,9 @@ static void test_scan_error(void)
CU_ASSERT_PTR_NULL(etmemd_do_scan(tpid, NULL));
CU_ASSERT_PTR_NULL(etmemd_do_scan(tpid, tk));
+ free(tk->eng->proj->scan_param);
+ free(tk->eng->proj);
+ free(tk->eng);
free(tk);
free(tpid);
}
@@ -292,6 +301,9 @@ static void test_etmem_scan_ok(void)
page_refs = etmemd_do_scan(tpid, tk);
CU_ASSERT_PTR_NOT_NULL(page_refs);
+ free(tk->eng->proj->scan_param);
+ free(tk->eng->proj);
+ free(tk->eng);
free(tk);
free(tpid);
clean_page_refs_unexpected(&page_refs);
diff --git a/etmem/test/etmem_slide_ops_llt_test/etmem_slide_ops_llt.c b/etmem/test/etmem_slide_ops_llt_test/etmem_slide_ops_llt.c
index 3a04a86..4521a60 100644
--- a/etmem/test/etmem_slide_ops_llt_test/etmem_slide_ops_llt.c
+++ b/etmem/test/etmem_slide_ops_llt_test/etmem_slide_ops_llt.c
@@ -275,9 +275,6 @@ static void test_etmem_task_swap_flag_error(void)
CU_ASSERT_EQUAL(etmemd_project_remove_task(config), OPT_SUCCESS);
destroy_slide_task_config(config);
- /* run slide_policy_interface fail */
- CU_ASSERT_EQUAL(slide_policy_interface(NULL, NULL), NULL);
-
/* run slide_do_migrate fail */
CU_ASSERT_EQUAL(slide_do_migrate(1, NULL), -1);
@@ -355,9 +352,6 @@ static void test_etmem_task_swap_threshold_error(void)
CU_ASSERT_EQUAL(etmemd_project_remove_task(config), OPT_SUCCESS);
destroy_slide_task_config(config);
- /* run slide_policy_interface fail */
- CU_ASSERT_EQUAL(slide_policy_interface(NULL, NULL), NULL);
-
/* run slide_do_migrate fail */
CU_ASSERT_EQUAL(slide_do_migrate(1, NULL), -1);
@@ -557,9 +551,6 @@ static void test_task_slide_invalid_config(void)
CU_ASSERT_EQUAL(etmemd_project_remove_task(config), OPT_SUCCESS);
destroy_slide_task_config(config);
- /* run slide_policy_interface fail */
- CU_ASSERT_EQUAL(slide_policy_interface(NULL, NULL), NULL);
-
/* run slide_do_migrate fail */
CU_ASSERT_EQUAL(slide_do_migrate(1, NULL), -1);
}
diff --git a/etmem/test/etmem_slide_ops_llt_test/test_slide_ops.sh b/etmem/test/etmem_slide_ops_llt_test/test_slide_ops.sh
old mode 100644
new mode 100755
diff --git a/etmem/test/etmem_socket_ops_llt_test/CMakeLists.txt b/etmem/test/etmem_socket_ops_llt_test/CMakeLists.txt
index 05239a0..e1d5591 100644
--- a/etmem/test/etmem_socket_ops_llt_test/CMakeLists.txt
+++ b/etmem/test/etmem_socket_ops_llt_test/CMakeLists.txt
@@ -23,4 +23,4 @@ SET(EXE etmem_socket_ops_llt)
add_executable(${EXE} etmem_socket_ops_llt.c)
-target_link_libraries(${EXE} cunit ${BUILD_DIR}/lib/libetmemd.so pthread dl rt boundscheck numa ${GLIB2_LIBRARIES})
+target_link_libraries(${EXE} cunit ${BUILD_DIR}/lib/libetmemd.so ${BUILD_DIR}/lib/libetmem.so pthread dl rt boundscheck numa ${GLIB2_LIBRARIES})
diff --git a/etmem/test/etmem_thirdparty_ops_llt_test/etmem_thirdparty_ops_llt.c b/etmem/test/etmem_thirdparty_ops_llt_test/etmem_thirdparty_ops_llt.c
index d7e7ae4..29a7e2f 100644
--- a/etmem/test/etmem_thirdparty_ops_llt_test/etmem_thirdparty_ops_llt.c
+++ b/etmem/test/etmem_thirdparty_ops_llt_test/etmem_thirdparty_ops_llt.c
@@ -160,11 +160,11 @@ void test_etmem_user_engine_0001(void)
/* test param NULL */
CU_ASSERT_EQUAL(etmemd_project_mgt_engine(NULL, NULL,
- NULL, DEFAULT_TASK, 0), OPT_SUCCESS);
+ NULL, DEFAULT_TASK, 0), OPT_INVAL);
CU_ASSERT_EQUAL(etmemd_project_mgt_engine(DEFAULT_PROJ, "no_exist_engine",
- "my_cmd", DEFAULT_TASK, 0), OPT_SUCCESS);
+ "my_cmd", DEFAULT_TASK, 0), OPT_ENG_NOEXIST);
CU_ASSERT_EQUAL(etmemd_project_mgt_engine(DEFAULT_PROJ, "my_engine",
- "my_cmd", "no_exist_task", 0), OPT_SUCCESS);
+ "my_cmd", "no_exist_task", 0), OPT_TASK_NOEXIST);
CU_ASSERT_EQUAL(etmemd_migrate_stop(DEFAULT_PROJ), OPT_SUCCESS);
@@ -219,7 +219,7 @@ static void test_etmem_user_engine_null(void)
CU_ASSERT_EQUAL(etmemd_project_add_engine(eng_config), OPT_SUCCESS);
CU_ASSERT_EQUAL(etmemd_project_add_task(task_config), OPT_SUCCESS);
CU_ASSERT_EQUAL(etmemd_migrate_start(DEFAULT_PROJ), OPT_SUCCESS);
- CU_ASSERT_EQUAL(etmemd_project_mgt_engine(DEFAULT_PROJ, "my_engine",
+ CU_ASSERT_NOT_EQUAL(etmemd_project_mgt_engine(DEFAULT_PROJ, "my_engine",
"my_cmd", DEFAULT_TASK, 0), OPT_SUCCESS);
CU_ASSERT_EQUAL(etmemd_migrate_stop(DEFAULT_PROJ), OPT_SUCCESS);
diff --git a/etmem/test/etmem_thirdparty_ops_llt_test/my_engine.c b/etmem/test/etmem_thirdparty_ops_llt_test/my_engine.c
index bd2a3bc..891e9d4 100644
--- a/etmem/test/etmem_thirdparty_ops_llt_test/my_engine.c
+++ b/etmem/test/etmem_thirdparty_ops_llt_test/my_engine.c
@@ -17,6 +17,7 @@
#include <unistd.h>
#include <string.h>
+#include "test_common.h"
#include "etmemd_thirdparty_export.h"
char *get_private_value(GKeyFile *config, char *group, char *key)
diff --git a/etmem/test/etmem_threadpool_ops_llt_test/CMakeLists.txt b/etmem/test/etmem_threadpool_ops_llt_test/CMakeLists.txt
index cb084cf..865620d 100644
--- a/etmem/test/etmem_threadpool_ops_llt_test/CMakeLists.txt
+++ b/etmem/test/etmem_threadpool_ops_llt_test/CMakeLists.txt
@@ -23,4 +23,4 @@ SET(EXE etmem_threadpool_ops_llt)
add_executable(${EXE} etmem_threadpool_ops_llt.c)
-target_link_libraries(${EXE} cunit ${BUILD_DIR}/lib/libetmemd.so pthread dl rt libboundscheck numa ${GLIB2_LIBRARIES})
+target_link_libraries(${EXE} cunit ${BUILD_DIR}/lib/libetmemd.so pthread dl rt boundscheck numa ${GLIB2_LIBRARIES})
diff --git a/etmem/test/etmem_threadpool_ops_llt_test/etmem_threadpool_ops_llt.c b/etmem/test/etmem_threadpool_ops_llt_test/etmem_threadpool_ops_llt.c
index 9917954..0b6ade1 100644
--- a/etmem/test/etmem_threadpool_ops_llt_test/etmem_threadpool_ops_llt.c
+++ b/etmem/test/etmem_threadpool_ops_llt_test/etmem_threadpool_ops_llt.c
@@ -147,7 +147,13 @@ static void test_thpool_addwk_mul(void)
static void init_thpool_objs(struct project *proj, struct engine *eng, struct task *tk)
{
- proj->interval = 1;
+ struct page_scan *page_scan = (struct page_scan *)calloc(1, sizeof(struct page_scan));
+ CU_ASSERT_PTR_NOT_NULL(page_scan);
+ proj->scan_param = page_scan;
+ proj->type = PAGE_SCAN;
+ page_scan->interval = 1;
+ page_scan->loop = 1;
+ page_scan->sleep = 1;
proj->start = true;
proj->name = "test_project";
eng->proj = proj;
@@ -170,6 +176,7 @@ static void test_thpool_start_error(void)
g_test_exec.tk = &tk;
CU_ASSERT_EQUAL(start_threadpool_work(&g_test_exec), -1);
+ free(proj.scan_param);
}
static void *task_executor(void *arg)
@@ -193,6 +200,7 @@ static void test_thpool_start_stop(void)
/* wait threadpool to work */
sleep(2);
stop_and_delete_threadpool_work(&tk);
+ free(proj.scan_param);
}
typedef enum {
diff --git a/etmem/test/etmem_timer_ops_llt_test/CMakeLists.txt b/etmem/test/etmem_timer_ops_llt_test/CMakeLists.txt
index 76aa48e..e5a815e 100644
--- a/etmem/test/etmem_timer_ops_llt_test/CMakeLists.txt
+++ b/etmem/test/etmem_timer_ops_llt_test/CMakeLists.txt
@@ -23,4 +23,4 @@ SET(EXE etmem_timer_ops_llt)
add_executable(${EXE} etmem_timer_ops_llt.c)
-target_link_libraries(${EXE} cunit ${BUILD_DIR}/lib/libetmemd.so pthread dl rt libboundscheck numa ${GLIB2_LIBRARIES})
+target_link_libraries(${EXE} cunit ${BUILD_DIR}/lib/libetmemd.so pthread dl rt boundscheck numa ${GLIB2_LIBRARIES})
--
1.8.3.1

87
0076-cslide-limit-hot_threshold-range-to-avoid-overflow-a.patch Normal file
View File

@ -0,0 +1,87 @@
From ececb8bc648391dd4ea536982d70fd7fa1984a0c Mon Sep 17 00:00:00 2001
From: Kemeng Shi <shikemeng@huawei.com>
Date: Fri, 13 May 2022 15:30:04 +0800
Subject: [PATCH 26/33] cslide: limit hot_threshold range to avoid overflow and
fix some memleak
Signed-off-by: Kemeng Shi <shikemeng@huawei.com>
---
etmem/inc/etmemd_inc/etmemd_scan.h | 1 +
etmem/src/etmemd_src/etmemd_cslide.c | 9 +++++++--
etmem/src/etmemd_src/etmemd_project.c | 1 +
etmem/src/etmemd_src/etmemd_task.c | 1 +
4 files changed, 10 insertions(+), 2 deletions(-)
diff --git a/etmem/inc/etmemd_inc/etmemd_scan.h b/etmem/inc/etmemd_inc/etmemd_scan.h
index 7c25152..47d710f 100644
--- a/etmem/inc/etmemd_inc/etmemd_scan.h
+++ b/etmem/inc/etmemd_inc/etmemd_scan.h
@@ -59,6 +59,7 @@ enum access_type_weight {
IDLE_TYPE_WEIGHT = 0,
READ_TYPE_WEIGHT = 1,
WRITE_TYPE_WEIGHT = 3,
+ MAX_ACCESS_WEIGHT = WRITE_TYPE_WEIGHT,
};
struct walk_address {
diff --git a/etmem/src/etmemd_src/etmemd_cslide.c b/etmem/src/etmemd_src/etmemd_cslide.c
index cbaa2e8..92e1aff 100644
--- a/etmem/src/etmemd_src/etmemd_cslide.c
+++ b/etmem/src/etmemd_src/etmemd_cslide.c
@@ -566,7 +566,7 @@ static struct cslide_pid_params *alloc_pid_params(struct cslide_eng_params *eng_
{
int i;
struct cslide_pid_params *params = calloc(1, sizeof(struct cslide_pid_params));
- int count = eng_params->loop;
+ int count = eng_params->loop * MAX_ACCESS_WEIGHT;
int pair_num = eng_params->node_map.cur_num;
int node_num = eng_params->mem.node_num;
@@ -1156,7 +1156,7 @@ static void move_hot_pages(struct cslide_eng_params *eng_params, struct flow_ctr
filter.flow_enough = is_hot_enough;
filter.filter_policy = to_hot_policy;
filter.ctrl = ctrl;
- filter.count_start = eng_params->loop;
+ filter.count_start = eng_params->loop * MAX_ACCESS_WEIGHT;
filter.count_end = eng_params->hot_threshold - 1;
filter.count_step = -1;
do_filter(&filter, eng_params);
@@ -2028,6 +2028,11 @@ static int fill_hot_threshold(void *obj, void *val)
return -1;
}
+ if (t > params->loop * MAX_ACCESS_WEIGHT + 1) {
+ // limit hot_threshold to avoid overflow in do_filter
+ t = params->loop * MAX_ACCESS_WEIGHT + 1;
+ }
+
params->hot_threshold = t;
return 0;
}
diff --git a/etmem/src/etmemd_src/etmemd_project.c b/etmem/src/etmemd_src/etmemd_project.c
index e238e66..5213bbd 100644
--- a/etmem/src/etmemd_src/etmemd_project.c
+++ b/etmem/src/etmemd_src/etmemd_project.c
@@ -729,6 +729,7 @@ static int project_fill_by_conf(GKeyFile *config, struct project *proj)
if (!check_swapcache_wmark_valid(proj)) {
etmemd_log(ETMEMD_LOG_ERR, "swapcache wmark is not valid, low wmark: %d, high wmark: %d",
proj->swapcache_low_wmark, proj->swapcache_high_wmark);
+ clear_project(proj);
return -1;
}
return 0;
diff --git a/etmem/src/etmemd_src/etmemd_task.c b/etmem/src/etmemd_src/etmemd_task.c
index 2a8cb3e..649d48e 100644
--- a/etmem/src/etmemd_src/etmemd_task.c
+++ b/etmem/src/etmemd_src/etmemd_task.c
@@ -428,6 +428,7 @@ static int fill_task_type(void *obj, void *val)
char *type = (char *)val;
if (strcmp(val, "pid") != 0 && strcmp(val, "name") != 0) {
etmemd_log(ETMEMD_LOG_ERR, "invalid task type, must be pid or name.\n");
+ free(val);
return -1;
}
--
1.8.3.1

136
0077-etmem-fix-the-problem-of-libso-no-permission-verific.patch Normal file
View File

@ -0,0 +1,136 @@
From 9c924ce79851c30763eec0e5f247e96d1efc7e61 Mon Sep 17 00:00:00 2001
From: liubo <liubo254@huawei.com>
Date: Tue, 17 May 2022 10:02:34 +0800
Subject: [PATCH 27/33] etmem: fix the problem of libso no permission
verification
etmem supports third-party policy injection. During the injection
process, the required so path is specified by the configuration
file.
However, in the so loading process, the lack of effective permission
verification may introduce problems.
Therefore, this patch adds permission verification during the so loading
process, and only allows root permissions to load so.
Signed-off-by: liubo <liubo254@huawei.com>
---
etmem/inc/etmemd_inc/etmemd_common.h | 4 ++-
etmem/src/etmemd_src/etmemd_common.c | 42 ++++++++++++++++++++++++++++++--
etmem/src/etmemd_src/etmemd_thirdparty.c | 11 +++++++--
3 files changed, 52 insertions(+), 5 deletions(-)
diff --git a/etmem/inc/etmemd_inc/etmemd_common.h b/etmem/inc/etmemd_inc/etmemd_common.h
index 03792a7..db71446 100644
--- a/etmem/inc/etmemd_inc/etmemd_common.h
+++ b/etmem/inc/etmemd_inc/etmemd_common.h
@@ -19,6 +19,7 @@
#include <stdio.h>
#include <stdbool.h>
#include <sys/ioctl.h>
+#include <sys/stat.h>
#define PROC_PATH "/proc/"
#define STATUS_FILE "/status"
@@ -39,6 +40,7 @@
#define MAX_SWAPCACHE_WMARK_VALUE 100
#define ARRAY_SIZE(array) (sizeof(array) / sizeof((array)[0]))
+#define S_IRWX_VALID (S_IRWXU | S_IRWXG | S_IRWXO)
/* in some system the max length of pid may be larger than 5, so we use 10 herr */
#define PID_STR_MAX_LEN 10
@@ -80,5 +82,5 @@ int get_mem_from_proc_file(const char *pid, const char *file_name, unsigned long
int dprintf_all(int fd, const char *format, ...);
int get_swap_threshold_inKB(const char *string, unsigned long *value);
-
+int file_permission_check(const char *file_path, mode_t mode);
#endif
diff --git a/etmem/src/etmemd_src/etmemd_common.c b/etmem/src/etmemd_src/etmemd_common.c
index dfbae6d..ab9a05b 100644
--- a/etmem/src/etmemd_src/etmemd_common.c
+++ b/etmem/src/etmemd_src/etmemd_common.c
@@ -22,10 +22,8 @@
#include <sys/time.h>
#include <ctype.h>
#include <unistd.h>
-#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
-#include <sys/types.h>
#include "securec.h"
#include "etmemd_common.h"
@@ -555,3 +553,43 @@ free_out:
out:
return ret;
}
+
+int file_permission_check(const char *file_path, mode_t mode)
+{
+ struct stat buf = {0};
+ mode_t file_p;
+
+ if (file_path == NULL || (mode & S_IRWX_VALID) == 0) {
+ etmemd_log(ETMEMD_LOG_ERR, "file_permission_check failed, invalid para\n");
+ return -1;
+ }
+
+ if (access(file_path, F_OK) != 0) {
+ etmemd_log(ETMEMD_LOG_ERR, "no such file: %s\n", file_path);
+ return -1;
+ }
+
+ if (stat(file_path, &buf) != 0) {
+ etmemd_log(ETMEMD_LOG_ERR, "get file : %s stat failed.\n", file_path);
+ return -1;
+ }
+
+ if (S_ISDIR(buf.st_mode)) {
+ etmemd_log(ETMEMD_LOG_ERR, "file : %s is a dir\n", file_path);
+ return -1;
+ }
+
+ if (buf.st_uid != 0 || buf.st_gid != 0) {
+ etmemd_log(ETMEMD_LOG_ERR, "file : %s should created by root\n", file_path);
+ return -1;
+ }
+
+ file_p = buf.st_mode & S_IRWX_VALID;
+ if (file_p != mode) {
+ etmemd_log(ETMEMD_LOG_WARN, "file : %s mode is wrong.\n", file_path);
+ return -1;
+ }
+
+ return 0;
+}
+
diff --git a/etmem/src/etmemd_src/etmemd_thirdparty.c b/etmem/src/etmemd_src/etmemd_thirdparty.c
index 8d1b50e..ec417b1 100644
--- a/etmem/src/etmemd_src/etmemd_thirdparty.c
+++ b/etmem/src/etmemd_src/etmemd_thirdparty.c
@@ -91,10 +91,17 @@ static int set_engine_ops(struct engine *eng, struct thirdparty_params *params)
return -1;
}
- handler = dlopen(params->libname, RTLD_NOW | RTLD_LOCAL);
+ if (file_permission_check(resolve_path, S_IRWXU) != 0 &&
+ file_permission_check(resolve_path, S_IRUSR | S_IXUSR) != 0) {
+ etmemd_log(ETMEMD_LOG_ERR, "file : %s permissions do not meet requirements."
+ "Only support 500 or 700\n", resolve_path);
+ return -1;
+ }
+
+ handler = dlopen(resolve_path, RTLD_NOW | RTLD_LOCAL);
err = dlerror();
if (err != NULL && handler == NULL) {
- etmemd_log(ETMEMD_LOG_ERR, "load library %s fail with error: %s\n", params->libname, err);
+ etmemd_log(ETMEMD_LOG_ERR, "load library %s fail with error: %s\n", resolve_path, err);
return -1;
}
--
1.8.3.1

103
0078-etmem-add-config-file-permission-check.patch Normal file
View File

@ -0,0 +1,103 @@
From 1e7058d6f063b57ef93664ff89aca2d0c760bcd7 Mon Sep 17 00:00:00 2001
From: liubo <liubo254@huawei.com>
Date: Tue, 24 May 2022 19:26:56 +0800
Subject: [PATCH 28/33] etmem: add config file permission check
Add permission verification and file size check in the
config file paring process.
Signed-off-by: liubo <liubo254@huawei.com>
---
etmem/inc/etmemd_inc/etmemd_common.h | 3 +++
etmem/src/etmemd_src/etmemd_common.c | 27 +++++++++++++++++++++++++++
etmem/src/etmemd_src/etmemd_rpc.c | 14 +++++++++++++-
3 files changed, 43 insertions(+), 1 deletion(-)
diff --git a/etmem/inc/etmemd_inc/etmemd_common.h b/etmem/inc/etmemd_inc/etmemd_common.h
index db71446..f3808b3 100644
--- a/etmem/inc/etmemd_inc/etmemd_common.h
+++ b/etmem/inc/etmemd_inc/etmemd_common.h
@@ -37,6 +37,7 @@
#define KB_TO_BYTE(s) ((s) << 10)
#define GB_TO_KB(s) ((s) << 20)
+#define MAX_CONFIG_FILE_SIZE (KB_TO_BYTE(10 * 1024))
#define MAX_SWAPCACHE_WMARK_VALUE 100
#define ARRAY_SIZE(array) (sizeof(array) / sizeof((array)[0]))
@@ -83,4 +84,6 @@ int dprintf_all(int fd, const char *format, ...);
int get_swap_threshold_inKB(const char *string, unsigned long *value);
int file_permission_check(const char *file_path, mode_t mode);
+int file_size_check(const char *file_path, off_t size);
+
#endif
diff --git a/etmem/src/etmemd_src/etmemd_common.c b/etmem/src/etmemd_src/etmemd_common.c
index ab9a05b..a12a43f 100644
--- a/etmem/src/etmemd_src/etmemd_common.c
+++ b/etmem/src/etmemd_src/etmemd_common.c
@@ -593,3 +593,30 @@ int file_permission_check(const char *file_path, mode_t mode)
return 0;
}
+int file_size_check(const char *file_path, off_t size)
+{
+ struct stat buf = {0};
+
+ if (file_path == NULL || size <= 0) {
+ etmemd_log(ETMEMD_LOG_ERR, "file_size_check failed, invalid para\n");
+ return -1;
+ }
+
+ if (access(file_path, F_OK) != 0) {
+ etmemd_log(ETMEMD_LOG_ERR, "no such file: %s\n", file_path);
+ return -1;
+ }
+
+ if (stat(file_path, &buf) != 0) {
+ etmemd_log(ETMEMD_LOG_ERR, "get file : %s stat failed.\n", file_path);
+ return -1;
+ }
+
+ if (buf.st_size > size) {
+ etmemd_log(ETMEMD_LOG_WARN, "file : %s is too big.\n", file_path);
+ return -1;
+ }
+
+ return 0;
+}
+
diff --git a/etmem/src/etmemd_src/etmemd_rpc.c b/etmem/src/etmemd_src/etmemd_rpc.c
index 6b23059..780ddce 100644
--- a/etmem/src/etmemd_src/etmemd_rpc.c
+++ b/etmem/src/etmemd_src/etmemd_rpc.c
@@ -181,13 +181,25 @@ static enum opt_result handle_obj_cmd(char *file_name, enum cmd_type type)
return OPT_INVAL;
}
+ if (file_permission_check(resolve_path, S_IRUSR) != 0 &&
+ file_permission_check(resolve_path, S_IRUSR | S_IWUSR) != 0) {
+ etmemd_log(ETMEMD_LOG_ERR, "config file : %s permissions do not meet requirements."
+ "Only support 600 or 400\n", resolve_path);
+ return OPT_INVAL;
+ }
+
+ if (file_size_check(resolve_path, MAX_CONFIG_FILE_SIZE) != 0) {
+ etmemd_log(ETMEMD_LOG_ERR, "config file: %s is too big.", resolve_path);
+ return OPT_INVAL;
+ }
+
config = g_key_file_new();
if (config == NULL) {
etmemd_log(ETMEMD_LOG_ERR, "get empty config file fail\n");
return OPT_INTER_ERR;
}
- if (g_key_file_load_from_file(config, file_name, G_KEY_FILE_NONE, NULL) == FALSE) {
+ if (g_key_file_load_from_file(config, resolve_path, G_KEY_FILE_NONE, NULL) == FALSE) {
etmemd_log(ETMEMD_LOG_ERR, "load config file fail\n");
ret = OPT_INTER_ERR;
goto free_file;
--
1.8.3.1

132
0079-etmem-fix-problem-of-abnormal-task-value.patch Normal file
View File

@ -0,0 +1,132 @@
From d51198f972f18ef99e887294c8c1de521ca66cf1 Mon Sep 17 00:00:00 2001
From: liubo <liubo254@huawei.com>
Date: Thu, 26 May 2022 15:26:30 +0800
Subject: [PATCH 29/33] etmem: fix problem of abnormal task value
1. When adding a task, if the task value contains
abnormal characters or the name is too long,
an error should be returned.
2. remove useless function.
Signed-off-by: liubo <liubo254@huawei.com>
---
etmem/inc/etmemd_inc/etmemd_common.h | 4 ++--
etmem/src/etmemd_src/etmemd_common.c | 39 ++++++++----------------------------
etmem/src/etmemd_src/etmemd_task.c | 7 +++++++
3 files changed, 17 insertions(+), 33 deletions(-)
diff --git a/etmem/inc/etmemd_inc/etmemd_common.h b/etmem/inc/etmemd_inc/etmemd_common.h
index f3808b3..795e600 100644
--- a/etmem/inc/etmemd_inc/etmemd_common.h
+++ b/etmem/inc/etmemd_inc/etmemd_common.h
@@ -45,6 +45,7 @@
/* in some system the max length of pid may be larger than 5, so we use 10 herr */
#define PID_STR_MAX_LEN 10
+#define NAME_STR_MAX_LEN 15
#define SWAP_THRESHOLD_MAX_LEN 10
#define PIPE_FD_LEN 2
@@ -76,7 +77,6 @@ void etmemd_safe_free(void **ptr);
FILE *etmemd_get_proc_file(const char *pid, const char *file, const char *mode);
int etmemd_send_ioctl_cmd(FILE *fp, struct ioctl_para *request);
-int get_keyword_and_value(const char *str, char *key, char *val);
unsigned long get_pagesize(void);
int get_mem_from_proc_file(const char *pid, const char *file_name, unsigned long *data, const char *cmpstr);
@@ -85,5 +85,5 @@ int dprintf_all(int fd, const char *format, ...);
int get_swap_threshold_inKB(const char *string, unsigned long *value);
int file_permission_check(const char *file_path, mode_t mode);
int file_size_check(const char *file_path, off_t size);
-
+int check_str_valid(const char *str);
#endif
diff --git a/etmem/src/etmemd_src/etmemd_common.c b/etmem/src/etmemd_src/etmemd_common.c
index a12a43f..649f472 100644
--- a/etmem/src/etmemd_src/etmemd_common.c
+++ b/etmem/src/etmemd_src/etmemd_common.c
@@ -357,54 +357,31 @@ static bool check_result_str_valid(const char *result)
return true;
}
-static unsigned long skip_colon_to_parse(const char *str, unsigned long idx)
-{
- size_t str_len = strlen(str);
-
- while (idx < str_len) {
- if (!is_valid_char_for_value(" :\t", str[idx])) {
- break;
- }
- idx += 1;
- }
-
- return idx;
-}
-
-/*
- * the caller should make sure that str is not NULL, and the content
- * of str must not contain ' ' or '\t' at the beginning and the end
- * */
-int get_keyword_and_value(const char *str, char *key, char *val)
+int check_str_valid(const char *str)
{
unsigned long idx = 0;
unsigned long end_idx;
size_t val_len;
+ char val[KEY_VALUE_MAX_LEN] = {0};
- get_valid_conf_str(str, idx, key, "%_", &end_idx);
- if (!check_result_str_valid(key)) {
- etmemd_log(ETMEMD_LOG_ERR, "get keyword of %s fail\n", str);
- return -1;
- }
- if (!is_valid_char_for_value(" :\t", str[end_idx])) {
- etmemd_log(ETMEMD_LOG_ERR, "%s contains invalid symbol in keyword\n", str);
+ if (str == NULL || strlen(str) == 0 || strlen(str) > NAME_STR_MAX_LEN) {
+ etmemd_log(ETMEMD_LOG_ERR, "input str: %s is invalid.\n", str);
return -1;
}
- etmemd_log(ETMEMD_LOG_DEBUG, "parse config get key: %s\n", key);
- /* skip the string contains ' ', '\t' and ':' between key and value */
- idx = skip_colon_to_parse(str, end_idx);
- val_len = strlen(str) - idx;
+ val_len = strlen(str);
get_valid_conf_str(str, idx, val, ".%/_-", &end_idx);
if (!check_result_str_valid(val)) {
- etmemd_log(ETMEMD_LOG_ERR, "get value of %s fail\n", str);
+ etmemd_log(ETMEMD_LOG_ERR, "get value of %s fail, contain invalid symbol\n", str);
return -1;
}
+
if (strlen(val) != val_len) {
etmemd_log(ETMEMD_LOG_ERR, "%s contains invalid symbol in value\n", str);
return -1;
}
+
etmemd_log(ETMEMD_LOG_DEBUG, "parse config get value: %s\n", val);
return 0;
diff --git a/etmem/src/etmemd_src/etmemd_task.c b/etmem/src/etmemd_src/etmemd_task.c
index 649d48e..dfe911f 100644
--- a/etmem/src/etmemd_src/etmemd_task.c
+++ b/etmem/src/etmemd_src/etmemd_task.c
@@ -440,6 +440,13 @@ static int fill_task_value(void *obj, void *val)
{
struct task *tk = (struct task *)obj;
char *value = (char *)val;
+
+ if (check_str_valid(value) != 0) {
+ etmemd_log(ETMEMD_LOG_ERR, "invalid task value, please check.\n");
+ free(val);
+ return -1;
+ }
+
tk->value = value;
return 0;
}
--
1.8.3.1

97
0080-etmem-remove-useless-dt-test-code.patch Normal file
View File

@ -0,0 +1,97 @@
From d41d6ad31312da775f94a4d68b0d6c826b3476db Mon Sep 17 00:00:00 2001
From: liubo <liubo254@huawei.com>
Date: Thu, 26 May 2022 15:39:25 +0800
Subject: [PATCH 30/33] etmem: remove useless dt test code
The function get_keyword_and_value is removed,
the useless dt test code should also be removed
the same time.
Signed-off-by: liubo <liubo254@huawei.com>
---
.../etmem_common_func_llt.c | 62 ----------------------
1 file changed, 62 deletions(-)
diff --git a/etmem/test/etmem_common_func_llt_test/etmem_common_func_llt.c b/etmem/test/etmem_common_func_llt_test/etmem_common_func_llt.c
index 3700baa..93755ee 100644
--- a/etmem/test/etmem_common_func_llt_test/etmem_common_func_llt.c
+++ b/etmem/test/etmem_common_func_llt_test/etmem_common_func_llt.c
@@ -336,66 +336,6 @@ static void test_etmemd_send_ioctl_cmd_ok(void)
fclose(fp);
}
-static void test_get_key_value_error(void)
-{
- char key[KEY_VALUE_MAX_LEN] = {};
- char value[KEY_VALUE_MAX_LEN] = {};
-
- CU_ASSERT_EQUAL(get_keyword_and_value("", key, value), -1);
- CU_ASSERT_EQUAL(get_keyword_and_value("abcd", key, value), -1);
- CU_ASSERT_EQUAL(get_keyword_and_value(":1", key, value), -1);
- CU_ASSERT_EQUAL(get_keyword_and_value("a:", key, value), -1);
- CU_ASSERT_EQUAL(get_keyword_and_value("#a:1", key, value), -1);
- CU_ASSERT_EQUAL(get_keyword_and_value("a.b:1", key, value), -1);
- CU_ASSERT_EQUAL(get_keyword_and_value("loop:2*4", key, value), -1);
-}
-
-static void test_get_key_value_ok(void)
-{
- char key[KEY_VALUE_MAX_LEN] = {};
- char value[KEY_VALUE_MAX_LEN] = {};
-
- CU_ASSERT_EQUAL(get_keyword_and_value("loop:30", key, value), 0);
- CU_ASSERT_STRING_EQUAL(key, "loop");
- CU_ASSERT_STRING_EQUAL(value, "30");
- CU_ASSERT_EQUAL(get_keyword_and_value("loop 30", key, value), 0);
- CU_ASSERT_STRING_EQUAL(key, "loop");
- CU_ASSERT_STRING_EQUAL(value, "30");
- CU_ASSERT_EQUAL(get_keyword_and_value("loop\t30", key, value), 0);
- CU_ASSERT_STRING_EQUAL(key, "loop");
- CU_ASSERT_STRING_EQUAL(value, "30");
- CU_ASSERT_EQUAL(get_keyword_and_value("loop :30", key, value), 0);
- CU_ASSERT_STRING_EQUAL(key, "loop");
- CU_ASSERT_STRING_EQUAL(value, "30");
- CU_ASSERT_EQUAL(get_keyword_and_value("loop\t:30", key, value), 0);
- CU_ASSERT_STRING_EQUAL(key, "loop");
- CU_ASSERT_STRING_EQUAL(value, "30");
- CU_ASSERT_EQUAL(get_keyword_and_value("loop\t 30", key, value), 0);
- CU_ASSERT_STRING_EQUAL(key, "loop");
- CU_ASSERT_STRING_EQUAL(value, "30");
- CU_ASSERT_EQUAL(get_keyword_and_value("a_b:1", key, value), 0);
- CU_ASSERT_STRING_EQUAL(key, "a_b");
- CU_ASSERT_STRING_EQUAL(value, "1");
- CU_ASSERT_EQUAL(get_keyword_and_value("%P:1", key, value), 0);
- CU_ASSERT_STRING_EQUAL(key, "%P");
- CU_ASSERT_STRING_EQUAL(value, "1");
- CU_ASSERT_EQUAL(get_keyword_and_value("%P:0.2", key, value), 0);
- CU_ASSERT_STRING_EQUAL(key, "%P");
- CU_ASSERT_STRING_EQUAL(value, "0.2");
- CU_ASSERT_EQUAL(get_keyword_and_value("%P:20%", key, value), 0);
- CU_ASSERT_STRING_EQUAL(key, "%P");
- CU_ASSERT_STRING_EQUAL(value, "20%");
- CU_ASSERT_EQUAL(get_keyword_and_value("output:/var/run", key, value), 0);
- CU_ASSERT_STRING_EQUAL(key, "output");
- CU_ASSERT_STRING_EQUAL(value, "/var/run");
- CU_ASSERT_EQUAL(get_keyword_and_value("engine:dynamic_fb", key, value), 0);
- CU_ASSERT_STRING_EQUAL(key, "engine");
- CU_ASSERT_STRING_EQUAL(value, "dynamic_fb");
- CU_ASSERT_EQUAL(get_keyword_and_value("name:qemu-kvm", key, value), 0);
- CU_ASSERT_STRING_EQUAL(key, "name");
- CU_ASSERT_STRING_EQUAL(value, "qemu-kvm");
-}
-
typedef enum {
CUNIT_SCREEN = 0,
CUNIT_XMLFILE,
@@ -434,8 +374,6 @@ int main(int argc, const char **argv)
CU_ADD_TEST(suite, test_get_uint_value_ok) == NULL ||
CU_ADD_TEST(suite, test_get_ulong_value_error) == NULL ||
CU_ADD_TEST(suite, test_get_ulong_value_ok) == NULL ||
- CU_ADD_TEST(suite, test_get_key_value_error) == NULL ||
- CU_ADD_TEST(suite, test_get_key_value_ok) == NULL ||
CU_ADD_TEST(suite, test_parse_cmdline_error) == NULL ||
CU_ADD_TEST(suite, test_parse_cmdline_ok) == NULL ||
CU_ADD_TEST(suite, test_get_proc_file_error) == NULL ||
--
1.8.3.1

46
0081-etmem-Fix-help-command.patch Normal file
View File

@ -0,0 +1,46 @@
From 0150a6b2f6ec1b6ecb076832982677dd10403f33 Mon Sep 17 00:00:00 2001
From: liubo <liubo254@huawei.com>
Date: Fri, 27 May 2022 09:09:02 +0800
Subject: [PATCH 31/33] etmem: Fix help command
Add missing content about engine command in help
documentation.
Signed-off-by: liubo <liubo254@huawei.com>
---
etmem/src/etmem_src/etmem.c | 4 ++--
etmem/src/etmem_src/etmem_engine.c | 3 ++-
2 files changed, 4 insertions(+), 3 deletions(-)
diff --git a/etmem/src/etmem_src/etmem.c b/etmem/src/etmem_src/etmem.c
index f243a75..694a477 100644
--- a/etmem/src/etmem_src/etmem.c
+++ b/etmem/src/etmem_src/etmem.c
@@ -32,8 +32,8 @@ static void usage(void)
" etmem OBJECT COMMAND\n"
" etmem help\n"
"\nParameters:\n"
- " OBJECT := { project | obj }\n"
- " COMMAND := { add | del | start | stop | show | help }\n");
+ " OBJECT := { project | obj | engine }\n"
+ " COMMAND := { add | del | start | stop | show | eng_cmd | help }\n");
}
static struct etmem_obj *etmem_obj_get(const char *name)
diff --git a/etmem/src/etmem_src/etmem_engine.c b/etmem/src/etmem_src/etmem_engine.c
index 675c38f..968f36b 100644
--- a/etmem/src/etmem_src/etmem_engine.c
+++ b/etmem/src/etmem_src/etmem_engine.c
@@ -36,7 +36,8 @@ static void engine_help(void)
" 2. socket name must be given.\n"
" 3. engine name must be given.\n"
" 4. engine cmd must be given.\n"
- " 5. eng_cmd is supported by engine own.\n");
+ " 5. eng_cmd is supported by engine own.\n"
+ " 6. cslide engine eng_cmd: showtaskpages, showhostpages.\n");
}
static void engine_parse_cmd(struct etmem_conf *conf, struct mem_proj *proj)
--
1.8.3.1

304
0082-etmem-add-etmem-project-License-and-notice-file.patch Normal file
View File

@ -0,0 +1,304 @@
From 8d7951eac3650d5e8dc73cd3a7be613f895293e9 Mon Sep 17 00:00:00 2001
From: liubo <liubo254@huawei.com>
Date: Thu, 9 Jun 2022 20:35:09 +0800
Subject: [PATCH] etmem: add etmem project License and notice file
Extract the license in the secondary bubdirectory
to the project directory and add the notice file.
Signed-off-by: liubo <liubo254@huawei.com>
---
License/NOTICE | 11 ++++
memRouter/License/LICENSE | 127 ----------------------------------------------
userswap/License/LICENSE | 127 ----------------------------------------------
3 files changed, 11 insertions(+), 254 deletions(-)
create mode 100644 License/NOTICE
delete mode 100644 memRouter/License/LICENSE
delete mode 100644 userswap/License/LICENSE
diff --git a/License/NOTICE b/License/NOTICE
new file mode 100644
index 0000000..0e06f47
--- /dev/null
+++ b/License/NOTICE
@@ -0,0 +1,11 @@
+etmem License
+=================
+
+Copyright (c) 2020 OPENATOM FOUNDATION and Huawei Technologies Co., Ltd. and others. All rights reserved.
+SPDX-License-Identifier: MulanPSL-2.0
+
+etmem software is licensed under the Mulan Permissive Software License，Version 2.
+
+See http://license.coscl.org.cn/MulanPSL2 for the MulanPSL-2.0 license text.
+
+See https://gitee.com/openeuler/etmem for support or download.
diff --git a/memRouter/License/LICENSE b/memRouter/License/LICENSE
deleted file mode 100644
index 0db93af..0000000
--- a/memRouter/License/LICENSE
+++ /dev/null
@@ -1,127 +0,0 @@
-木兰宽松许可证, 第2版
-
- 木兰宽松许可证， 第2版
- 2020年1月 http://license.coscl.org.cn/MulanPSL2
-
-
- 您对“软件”的复制、使用、修改及分发受木兰宽松许可证，第2版（“本许可证”）的如下条款的约束：
-
- 0. 定义
-
- “软件”是指由“贡献”构成的许可在“本许可证”下的程序和相关文档的集合。
-
- “贡献”是指由任一“贡献者”许可在“本许可证”下的受版权法保护的作品。
-
- “贡献者”是指将受版权法保护的作品许可在“本许可证”下的自然人或“法人实体”。
-
- “法人实体”是指提交贡献的机构及其“关联实体”。
-
- “关联实体”是指，对“本许可证”下的行为方而言，控制、受控制或与其共同受控制的机构，此处的控制是指有受控方或共同受控方至少50%直接或间接的投票权、资金或其他有价证券。
-
- 1. 授予版权许可
-
- 每个“贡献者”根据“本许可证”授予您永久性的、全球性的、免费的、非独占的、不可撤销的版权许可，您可以复制、使用、修改、分发其“贡献”，不论修改与否。
-
- 2. 授予专利许可
-
- 每个“贡献者”根据“本许可证”授予您永久性的、全球性的、免费的、非独占的、不可撤销的（根据本条规定撤销除外）专利许可，供您制造、委托制造、使用、许诺销售、销售、进口其“贡献”或以其他方式转移其“贡献”。前述专利许可仅限于“贡献者”现在或将来拥有或控制的其“贡献”本身或其“贡献”与许可“贡献”时的“软件”结合而将必然会侵犯的专利权利要求，不包括对“贡献”的修改或包含“贡献”的其他结合。如果您或您的“关联实体”直接或间接地，就“软件”或其中的“贡献”对任何人发起专利侵权诉讼（包括反诉或交叉诉讼）或其他专利维权行动，指控其侵犯专利权，则“本许可证”授予您对“软件”的专利许可自您提起诉讼或发起维权行动之日终止。
-
- 3. 无商标许可
-
- “本许可证”不提供对“贡献者”的商品名称、商标、服务标志或产品名称的商标许可，但您为满足第4条规定的声明义务而必须使用除外。
-
- 4. 分发限制
-
- 您可以在任何媒介中将“软件”以源程序形式或可执行形式重新分发，不论修改与否，但您必须向接收者提供“本许可证”的副本，并保留“软件”中的版权、商标、专利及免责声明。
-
- 5. 免责声明与责任限制
-
- “软件”及其中的“贡献”在提供时不带任何明示或默示的担保。在任何情况下，“贡献者”或版权所有者不对任何人因使用“软件”或其中的“贡献”而引发的任何直接或间接损失承担责任，不论因何种原因导致或者基于何种法律理论，即使其曾被建议有此种损失的可能性。
-
- 6. 语言
- “本许可证”以中英文双语表述，中英文版本具有同等法律效力。如果中英文版本存在任何冲突不一致，以中文版为准。
-
- 条款结束
-
- 如何将木兰宽松许可证，第2版，应用到您的软件
-
- 如果您希望将木兰宽松许可证，第2版，应用到您的新软件，为了方便接收者查阅，建议您完成如下三步：
-
- 1， 请您补充如下声明中的空白，包括软件名、软件的首次发表年份以及您作为版权人的名字；
-
- 2， 请您在软件包的一级目录下创建以“LICENSE”为名的文件，将整个许可证文本放入该文件中；
-
- 3， 请将如下声明文本放入每个源文件的头部注释中。
-
- Copyright (c) [Year] [name of copyright holder]
- [Software Name] is licensed under Mulan PSL v2.
- You can use this software according to the terms and conditions of the Mulan PSL v2.
- You may obtain a copy of Mulan PSL v2 at:
- http://license.coscl.org.cn/MulanPSL2
- THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- See the Mulan PSL v2 for more details.
-
-
- Mulan Permissive Software License，Version 2
-
- Mulan Permissive Software License，Version 2 (Mulan PSL v2)
- January 2020 http://license.coscl.org.cn/MulanPSL2
-
- Your reproduction, use, modification and distribution of the Software shall be subject to Mulan PSL v2 (this License) with the following terms and conditions:
-
- 0. Definition
-
- Software means the program and related documents which are licensed under this License and comprise all Contribution(s).
-
- Contribution means the copyrightable work licensed by a particular Contributor under this License.
-
- Contributor means the Individual or Legal Entity who licenses its copyrightable work under this License.
-
- Legal Entity means the entity making a Contribution and all its Affiliates.
-
- Affiliates means entities that control, are controlled by, or are under common control with the acting entity under this License, ‘control’ means direct or indirect ownership of at least fifty percent (50%) of the voting power, capital or other securities of controlled or commonly controlled entity.
-
- 1. Grant of Copyright License
-
- Subject to the terms and conditions of this License, each Contributor hereby grants to you a perpetual, worldwide, royalty-free, non-exclusive, irrevocable copyright license to reproduce, use, modify, or distribute its Contribution, with modification or not.
-
- 2. Grant of Patent License
-
- Subject to the terms and conditions of this License, each Contributor hereby grants to you a perpetual, worldwide, royalty-free, non-exclusive, irrevocable (except for revocation under this Section) patent license to make, have made, use, offer for sale, sell, import or otherwise transfer its Contribution, where such patent license is only limited to the patent claims owned or controlled by such Contributor now or in future which will be necessarily infringed by its Contribution alone, or by combination of the Contribution with the Software to which the Contribution was contributed. The patent license shall not apply to any modification of the Contribution, and any other combination which includes the Contribution. If you or your Affiliates directly or indirectly institute patent litigation (including a cross claim or counterclaim in a litigation) or other patent enforcement activities against any individual or entity by alleging that the Software or any Contribution in it infringes patents, then any patent license granted to you under this License for the Software shall terminate as of the date such litigation or activity is filed or taken.
-
- 3. No Trademark License
-
- No trademark license is granted to use the trade names, trademarks, service marks, or product names of Contributor, except as required to fulfill notice requirements in Section 4.
-
- 4. Distribution Restriction
-
- You may distribute the Software in any medium with or without modification, whether in source or executable forms, provided that you provide recipients with a copy of this License and retain copyright, patent, trademark and disclaimer statements in the Software.
-
- 5. Disclaimer of Warranty and Limitation of Liability
-
- THE SOFTWARE AND CONTRIBUTION IN IT ARE PROVIDED WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED. IN NO EVENT SHALL ANY CONTRIBUTOR OR COPYRIGHT HOLDER BE LIABLE TO YOU FOR ANY DAMAGES, INCLUDING, BUT NOT LIMITED TO ANY DIRECT, OR INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING FROM YOUR USE OR INABILITY TO USE THE SOFTWARE OR THE CONTRIBUTION IN IT, NO MATTER HOW IT’S CAUSED OR BASED ON WHICH LEGAL THEORY, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
-
- 6. Language
-
- THIS LICENSE IS WRITTEN IN BOTH CHINESE AND ENGLISH, AND THE CHINESE VERSION AND ENGLISH VERSION SHALL HAVE THE SAME LEGAL EFFECT. IN THE CASE OF DIVERGENCE BETWEEN THE CHINESE AND ENGLISH VERSIONS, THE CHINESE VERSION SHALL PREVAIL.
-
- END OF THE TERMS AND CONDITIONS
-
- How to Apply the Mulan Permissive Software License，Version 2 (Mulan PSL v2) to Your Software
-
- To apply the Mulan PSL v2 to your work, for easy identification by recipients, you are suggested to complete following three steps:
-
- i Fill in the blanks in following statement, including insert your software name, the year of the first publication of your software, and your name identified as the copyright owner;
-
- ii Create a file named “LICENSE” which contains the whole context of this License in the first directory of your software package;
-
- iii Attach the statement to the appropriate annotated syntax at the beginning of each source file.
-
-
- Copyright (c) [Year] [name of copyright holder]
- [Software Name] is licensed under Mulan PSL v2.
- You can use this software according to the terms and conditions of the Mulan PSL v2.
- You may obtain a copy of Mulan PSL v2 at:
- http://license.coscl.org.cn/MulanPSL2
- THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- See the Mulan PSL v2 for more details.
diff --git a/userswap/License/LICENSE b/userswap/License/LICENSE
deleted file mode 100644
index 0db93af..0000000
--- a/userswap/License/LICENSE
+++ /dev/null
@@ -1,127 +0,0 @@
-木兰宽松许可证, 第2版
-
- 木兰宽松许可证， 第2版
- 2020年1月 http://license.coscl.org.cn/MulanPSL2
-
-
- 您对“软件”的复制、使用、修改及分发受木兰宽松许可证，第2版（“本许可证”）的如下条款的约束：
-
- 0. 定义
-
- “软件”是指由“贡献”构成的许可在“本许可证”下的程序和相关文档的集合。
-
- “贡献”是指由任一“贡献者”许可在“本许可证”下的受版权法保护的作品。
-
- “贡献者”是指将受版权法保护的作品许可在“本许可证”下的自然人或“法人实体”。
-
- “法人实体”是指提交贡献的机构及其“关联实体”。
-
- “关联实体”是指，对“本许可证”下的行为方而言，控制、受控制或与其共同受控制的机构，此处的控制是指有受控方或共同受控方至少50%直接或间接的投票权、资金或其他有价证券。
-
- 1. 授予版权许可
-
- 每个“贡献者”根据“本许可证”授予您永久性的、全球性的、免费的、非独占的、不可撤销的版权许可，您可以复制、使用、修改、分发其“贡献”，不论修改与否。
-
- 2. 授予专利许可
-
- 每个“贡献者”根据“本许可证”授予您永久性的、全球性的、免费的、非独占的、不可撤销的（根据本条规定撤销除外）专利许可，供您制造、委托制造、使用、许诺销售、销售、进口其“贡献”或以其他方式转移其“贡献”。前述专利许可仅限于“贡献者”现在或将来拥有或控制的其“贡献”本身或其“贡献”与许可“贡献”时的“软件”结合而将必然会侵犯的专利权利要求，不包括对“贡献”的修改或包含“贡献”的其他结合。如果您或您的“关联实体”直接或间接地，就“软件”或其中的“贡献”对任何人发起专利侵权诉讼（包括反诉或交叉诉讼）或其他专利维权行动，指控其侵犯专利权，则“本许可证”授予您对“软件”的专利许可自您提起诉讼或发起维权行动之日终止。
-
- 3. 无商标许可
-
- “本许可证”不提供对“贡献者”的商品名称、商标、服务标志或产品名称的商标许可，但您为满足第4条规定的声明义务而必须使用除外。
-
- 4. 分发限制
-
- 您可以在任何媒介中将“软件”以源程序形式或可执行形式重新分发，不论修改与否，但您必须向接收者提供“本许可证”的副本，并保留“软件”中的版权、商标、专利及免责声明。
-
- 5. 免责声明与责任限制
-
- “软件”及其中的“贡献”在提供时不带任何明示或默示的担保。在任何情况下，“贡献者”或版权所有者不对任何人因使用“软件”或其中的“贡献”而引发的任何直接或间接损失承担责任，不论因何种原因导致或者基于何种法律理论，即使其曾被建议有此种损失的可能性。
-
- 6. 语言
- “本许可证”以中英文双语表述，中英文版本具有同等法律效力。如果中英文版本存在任何冲突不一致，以中文版为准。
-
- 条款结束
-
- 如何将木兰宽松许可证，第2版，应用到您的软件
-
- 如果您希望将木兰宽松许可证，第2版，应用到您的新软件，为了方便接收者查阅，建议您完成如下三步：
-
- 1， 请您补充如下声明中的空白，包括软件名、软件的首次发表年份以及您作为版权人的名字；
-
- 2， 请您在软件包的一级目录下创建以“LICENSE”为名的文件，将整个许可证文本放入该文件中；
-
- 3， 请将如下声明文本放入每个源文件的头部注释中。
-
- Copyright (c) [Year] [name of copyright holder]
- [Software Name] is licensed under Mulan PSL v2.
- You can use this software according to the terms and conditions of the Mulan PSL v2.
- You may obtain a copy of Mulan PSL v2 at:
- http://license.coscl.org.cn/MulanPSL2
- THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- See the Mulan PSL v2 for more details.
-
-
- Mulan Permissive Software License，Version 2
-
- Mulan Permissive Software License，Version 2 (Mulan PSL v2)
- January 2020 http://license.coscl.org.cn/MulanPSL2
-
- Your reproduction, use, modification and distribution of the Software shall be subject to Mulan PSL v2 (this License) with the following terms and conditions:
-
- 0. Definition
-
- Software means the program and related documents which are licensed under this License and comprise all Contribution(s).
-
- Contribution means the copyrightable work licensed by a particular Contributor under this License.
-
- Contributor means the Individual or Legal Entity who licenses its copyrightable work under this License.
-
- Legal Entity means the entity making a Contribution and all its Affiliates.
-
- Affiliates means entities that control, are controlled by, or are under common control with the acting entity under this License, ‘control’ means direct or indirect ownership of at least fifty percent (50%) of the voting power, capital or other securities of controlled or commonly controlled entity.
-
- 1. Grant of Copyright License
-
- Subject to the terms and conditions of this License, each Contributor hereby grants to you a perpetual, worldwide, royalty-free, non-exclusive, irrevocable copyright license to reproduce, use, modify, or distribute its Contribution, with modification or not.
-
- 2. Grant of Patent License
-
- Subject to the terms and conditions of this License, each Contributor hereby grants to you a perpetual, worldwide, royalty-free, non-exclusive, irrevocable (except for revocation under this Section) patent license to make, have made, use, offer for sale, sell, import or otherwise transfer its Contribution, where such patent license is only limited to the patent claims owned or controlled by such Contributor now or in future which will be necessarily infringed by its Contribution alone, or by combination of the Contribution with the Software to which the Contribution was contributed. The patent license shall not apply to any modification of the Contribution, and any other combination which includes the Contribution. If you or your Affiliates directly or indirectly institute patent litigation (including a cross claim or counterclaim in a litigation) or other patent enforcement activities against any individual or entity by alleging that the Software or any Contribution in it infringes patents, then any patent license granted to you under this License for the Software shall terminate as of the date such litigation or activity is filed or taken.
-
- 3. No Trademark License
-
- No trademark license is granted to use the trade names, trademarks, service marks, or product names of Contributor, except as required to fulfill notice requirements in Section 4.
-
- 4. Distribution Restriction
-
- You may distribute the Software in any medium with or without modification, whether in source or executable forms, provided that you provide recipients with a copy of this License and retain copyright, patent, trademark and disclaimer statements in the Software.
-
- 5. Disclaimer of Warranty and Limitation of Liability
-
- THE SOFTWARE AND CONTRIBUTION IN IT ARE PROVIDED WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED. IN NO EVENT SHALL ANY CONTRIBUTOR OR COPYRIGHT HOLDER BE LIABLE TO YOU FOR ANY DAMAGES, INCLUDING, BUT NOT LIMITED TO ANY DIRECT, OR INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING FROM YOUR USE OR INABILITY TO USE THE SOFTWARE OR THE CONTRIBUTION IN IT, NO MATTER HOW IT’S CAUSED OR BASED ON WHICH LEGAL THEORY, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
-
- 6. Language
-
- THIS LICENSE IS WRITTEN IN BOTH CHINESE AND ENGLISH, AND THE CHINESE VERSION AND ENGLISH VERSION SHALL HAVE THE SAME LEGAL EFFECT. IN THE CASE OF DIVERGENCE BETWEEN THE CHINESE AND ENGLISH VERSIONS, THE CHINESE VERSION SHALL PREVAIL.
-
- END OF THE TERMS AND CONDITIONS
-
- How to Apply the Mulan Permissive Software License，Version 2 (Mulan PSL v2) to Your Software
-
- To apply the Mulan PSL v2 to your work, for easy identification by recipients, you are suggested to complete following three steps:
-
- i Fill in the blanks in following statement, including insert your software name, the year of the first publication of your software, and your name identified as the copyright owner;
-
- ii Create a file named “LICENSE” which contains the whole context of this License in the first directory of your software package;
-
- iii Attach the statement to the appropriate annotated syntax at the beginning of each source file.
-
-
- Copyright (c) [Year] [name of copyright holder]
- [Software Name] is licensed under Mulan PSL v2.
- You can use this software according to the terms and conditions of the Mulan PSL v2.
- You may obtain a copy of Mulan PSL v2 at:
- http://license.coscl.org.cn/MulanPSL2
- THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- See the Mulan PSL v2 for more details.
--
1.8.3.1

51
0083-etmem-fix-memory-leak.patch Normal file
View File

@ -0,0 +1,51 @@
From 4bca2f765de38ce263cf5c7507c717b04395b012 Mon Sep 17 00:00:00 2001
From: liubo <liubo254@huawei.com>
Date: Mon, 13 Jun 2022 15:59:05 +0800
Subject: [PATCH 33/33] etmem: fix memory leak
In the configuration file parsing process, if the parameter
value is not configured, the val memory should be released.
When the project is deleted, the memory of the pid list
corresponding to the task needs to be released.
Signed-off-by: liubo <liubo254@huawei.com>
---
etmem/src/etmemd_src/etmemd_file.c | 8 +++++++-
etmem/src/etmemd_src/etmemd_slide.c | 1 +
2 files changed, 8 insertions(+), 1 deletion(-)
diff --git a/etmem/src/etmemd_src/etmemd_file.c b/etmem/src/etmemd_src/etmemd_file.c
index b7dc27f..d204685 100644
--- a/etmem/src/etmemd_src/etmemd_file.c
+++ b/etmem/src/etmemd_src/etmemd_file.c
@@ -35,7 +35,13 @@ static int parse_item(GKeyFile *config, char *group_name, struct config_item *it
break;
case STR_VAL:
val = (void *)g_key_file_get_string(config, group_name, item->key, &error);
- if (val == NULL || strlen(val) == 0) {
+ if (val == NULL) {
+ etmemd_log(ETMEMD_LOG_ERR, "section %s of group [%s] should not be empty\n", item->key, group_name);
+ return -1;
+ }
+
+ if (strlen(val) == 0) {
+ free(val);
etmemd_log(ETMEMD_LOG_ERR, "section %s of group [%s] should not be empty\n", item->key, group_name);
return -1;
}
diff --git a/etmem/src/etmemd_src/etmemd_slide.c b/etmem/src/etmemd_src/etmemd_slide.c
index 236778a..a3c474b 100644
--- a/etmem/src/etmemd_src/etmemd_slide.c
+++ b/etmem/src/etmemd_src/etmemd_slide.c
@@ -388,6 +388,7 @@ static void slide_stop_task(struct engine *eng, struct task *tk)
struct slide_params *params = tk->params;
stop_and_delete_threadpool_work(tk);
+ etmemd_free_task_pids(tk);
free(params->executor);
params->executor = NULL;
}
--
1.8.3.1

197
0084-etmem-add-dt-test-code-for-permission-check.patch Normal file
View File

@ -0,0 +1,197 @@
From 890906f4d42ca257a9b5c6b805b3602743eb982a Mon Sep 17 00:00:00 2001
From: liubo <liubo254@huawei.com>
Date: Mon, 1 Aug 2022 16:25:48 +0800
Subject: [PATCH] etmem: add dt test code for permission check
Add dt test code to etmem_common functions for
the config permission check.
Signed-off-by: liubo <liubo254@huawei.com>
---
.../etmem_common_func_llt.c | 54 ++++++++++++++++++-
.../etmem_scan_ops_export_llt.c | 2 +-
.../etmem_scan_ops_llt.c | 2 +-
.../etmem_slide_ops_llt.c | 14 +++++
.../etmem_socket_ops_llt.c | 8 +--
5 files changed, 73 insertions(+), 7 deletions(-)
diff --git a/etmem/test/etmem_common_func_llt_test/etmem_common_func_llt.c b/etmem/test/etmem_common_func_llt_test/etmem_common_func_llt.c
index 93755ee..7f6a6ee 100644
--- a/etmem/test/etmem_common_func_llt_test/etmem_common_func_llt.c
+++ b/etmem/test/etmem_common_func_llt_test/etmem_common_func_llt.c
@@ -18,6 +18,7 @@
#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
+#include <sys/stat.h>
#include <stdbool.h>
#include <fcntl.h>
#include <limits.h>
@@ -34,7 +35,7 @@
#include "etmemd_scan.h"
#include "securec.h"
-#define RECLAIM_SWAPCACHE_MAGIC 0X77
+#define RECLAIM_SWAPCACHE_MAGIC 0x77
#define RECLAIM_SWAPCACHE_ON _IOW(RECLAIM_SWAPCACHE_MAGIC, 0x1, unsigned int)
#define SET_SWAPCACHE_WMARK _IOW(RECLAIM_SWAPCACHE_MAGIC, 0x2, unsigned int)
@@ -336,6 +337,53 @@ static void test_etmemd_send_ioctl_cmd_ok(void)
fclose(fp);
}
+static void test_check_str_error(void)
+{
+ char *str = NULL;
+
+ CU_ASSERT_EQUAL(check_str_valid(str), -1);
+ CU_ASSERT_EQUAL(check_str_valid(""), -1);
+ CU_ASSERT_EQUAL(check_str_valid(":1"), -1);
+ CU_ASSERT_EQUAL(check_str_valid("a:"), -1);
+ CU_ASSERT_EQUAL(check_str_valid("#a:1"), -1);
+ CU_ASSERT_EQUAL(check_str_valid("a.b:1"), -1);
+ CU_ASSERT_EQUAL(check_str_valid("2*4"), -1);
+ CU_ASSERT_EQUAL(check_str_valid("2&^4"), -1);
+ CU_ASSERT_EQUAL(check_str_valid("longgerthan15charchar"), -1);
+}
+
+static void test_check_str_ok(void)
+{
+ CU_ASSERT_EQUAL(check_str_valid("30"), 0);
+ CU_ASSERT_EQUAL(check_str_valid("mysqld"), 0);
+ CU_ASSERT_EQUAL(check_str_valid("swap_test"), 0);
+ CU_ASSERT_EQUAL(check_str_valid("swap-test"), 0);
+ CU_ASSERT_EQUAL(check_str_valid("swap.test"), 0);
+ CU_ASSERT_EQUAL(check_str_valid("swap%test"), 0);
+ CU_ASSERT_EQUAL(check_str_valid("swap/var/run"), 0);
+}
+
+static void test_file_check_error(void)
+{
+ char *file_path = NULL;
+
+ CU_ASSERT_EQUAL(file_size_check(file_path, MAX_CONFIG_FILE_SIZE), -1);
+ CU_ASSERT_EQUAL(file_size_check("/proc/1/status", -1), -1);
+ CU_ASSERT_EQUAL(file_size_check("/proc/1/status", 0), -1);
+ CU_ASSERT_EQUAL(file_size_check("/proc/file_dont_exist/status", MAX_CONFIG_FILE_SIZE - 1), -1);
+
+ CU_ASSERT_EQUAL(file_permission_check(file_path, S_IRWX_VALID), -1);
+ CU_ASSERT_EQUAL(file_permission_check("/proc/1/status", 0), -1);
+ CU_ASSERT_EQUAL(file_permission_check("/proc/file_dont_exist/status", S_IRWX_VALID), -1);
+ CU_ASSERT_EQUAL(file_permission_check("/proc/1", S_IRWX_VALID), -1);
+}
+
+static void test_file_check_ok(void)
+{
+ CU_ASSERT_EQUAL(file_size_check("/proc/1/status", MAX_CONFIG_FILE_SIZE), 0);
+ CU_ASSERT_EQUAL(file_permission_check("/proc/1/status", S_IRUSR | S_IRGRP | S_IROTH), 0);
+}
+
typedef enum {
CUNIT_SCREEN = 0,
CUNIT_XMLFILE,
@@ -374,6 +422,10 @@ int main(int argc, const char **argv)
CU_ADD_TEST(suite, test_get_uint_value_ok) == NULL ||
CU_ADD_TEST(suite, test_get_ulong_value_error) == NULL ||
CU_ADD_TEST(suite, test_get_ulong_value_ok) == NULL ||
+ CU_ADD_TEST(suite, test_check_str_error) == NULL ||
+ CU_ADD_TEST(suite, test_check_str_ok) == NULL ||
+ CU_ADD_TEST(suite, test_file_check_error) == NULL ||
+ CU_ADD_TEST(suite, test_file_check_ok) == NULL ||
CU_ADD_TEST(suite, test_parse_cmdline_error) == NULL ||
CU_ADD_TEST(suite, test_parse_cmdline_ok) == NULL ||
CU_ADD_TEST(suite, test_get_proc_file_error) == NULL ||
diff --git a/etmem/test/etmem_scan_ops_export_llt_test/etmem_scan_ops_export_llt.c b/etmem/test/etmem_scan_ops_export_llt_test/etmem_scan_ops_export_llt.c
index e8e6098..2625cde 100644
--- a/etmem/test/etmem_scan_ops_export_llt_test/etmem_scan_ops_export_llt.c
+++ b/etmem/test/etmem_scan_ops_export_llt_test/etmem_scan_ops_export_llt.c
@@ -191,7 +191,7 @@ static void test_etmem_exp_scan_005(void)
CU_ASSERT_EQUAL(etmemd_scan_init(), 0);
const char *pid = "1";
- char *vmflags_array[10] = {"rd"};
+ char *vmflags_array[10] = {"wr"};
int vmflag_num = 1;
int is_anon_only = false;
struct vmas *vmas = NULL;
diff --git a/etmem/test/etmem_scan_ops_llt_test/etmem_scan_ops_llt.c b/etmem/test/etmem_scan_ops_llt_test/etmem_scan_ops_llt.c
index cb1ccbc..d717b44 100644
--- a/etmem/test/etmem_scan_ops_llt_test/etmem_scan_ops_llt.c
+++ b/etmem/test/etmem_scan_ops_llt_test/etmem_scan_ops_llt.c
@@ -233,7 +233,7 @@ static void test_get_page_refs_valid()
CU_ASSERT_EQUAL(etmemd_scan_init(), 0);
const char *pid = "1";
- char *vmflags_array[10] = {"rd"};
+ char *vmflags_array[10] = {"wr"};
int vmflag_num = 1;
int is_anon_only = false;
struct vmas *vmas = NULL;
diff --git a/etmem/test/etmem_slide_ops_llt_test/etmem_slide_ops_llt.c b/etmem/test/etmem_slide_ops_llt_test/etmem_slide_ops_llt.c
index 4521a60..a476f29 100644
--- a/etmem/test/etmem_slide_ops_llt_test/etmem_slide_ops_llt.c
+++ b/etmem/test/etmem_slide_ops_llt_test/etmem_slide_ops_llt.c
@@ -479,6 +479,20 @@ static void test_task_common_invalid_config(void)
config = construct_slide_task_config(&slide_task);
CU_ASSERT_NOT_EQUAL(etmemd_project_add_task(config), OPT_SUCCESS);
destroy_slide_task_config(config);
+
+ /* task value invalid */
+ init_slide_task(&slide_task);
+ slide_task.task_param.value = "";
+ config = construct_slide_task_config(&slide_task);
+ CU_ASSERT_NOT_EQUAL(etmemd_project_add_task(config), OPT_SUCCESS);
+ destroy_slide_task_config(config);
+
+ /* task value invalid */
+ init_slide_task(&slide_task);
+ slide_task.task_param.type = "name*^";
+ config = construct_slide_task_config(&slide_task);
+ CU_ASSERT_NOT_EQUAL(etmemd_project_add_task(config), OPT_SUCCESS);
+ destroy_slide_task_config(config);
}
static void test_task_slide_invalid_config(void)
diff --git a/etmem/test/etmem_socket_ops_llt_test/etmem_socket_ops_llt.c b/etmem/test/etmem_socket_ops_llt_test/etmem_socket_ops_llt.c
index 387ffd1..8f0f0f8 100644
--- a/etmem/test/etmem_socket_ops_llt_test/etmem_socket_ops_llt.c
+++ b/etmem/test/etmem_socket_ops_llt_test/etmem_socket_ops_llt.c
@@ -155,7 +155,7 @@ static void etmem_pro_add_error(void)
CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_ADD, "test", "file_name", ""), -1);
file_name = get_length_str(RPC_SEND_FILE_MAX);
CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_ADD, "test", file_name, ""), -1);
- CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_ADD, "test", "file_name", "sock_name"), -1);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_ADD, "test", file_name, "sock_name"), -1);
free(file_name);
}
@@ -183,7 +183,7 @@ static void etmem_pro_del_error(void)
CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_DEL, "test", "file_name", ""), -1);
file_name = get_length_str(RPC_SEND_FILE_MAX);
CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_DEL, "test", file_name, ""), -1);
- CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_DEL, "test", "file_name", "sock_name"), -1);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_DEL, "test", file_name, "sock_name"), -1);
free(file_name);
}
@@ -211,7 +211,7 @@ static void etmem_pro_start_error(void)
CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_START, "test", "file_name", ""), -1);
file_name = get_length_str(RPC_SEND_FILE_MAX);
CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_START, "test", file_name, ""), -1);
- CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_START, "test", "file_name", "sock_name"), -1);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_START, "test", file_name, "sock_name"), -1);
free(file_name);
}
@@ -239,7 +239,7 @@ static void etmem_pro_stop_error(void)
CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_STOP, "test", "file_name", ""), -1);
file_name = get_length_str(RPC_SEND_FILE_MAX);
CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_STOP, "test", file_name, ""), -1);
- CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_STOP, "test", "file_name", "sock_name"), -1);
+ CU_ASSERT_EQUAL(etmem_socket_client(ETMEM_CMD_STOP, "test", file_name, "sock_name"), -1);
free(file_name);
}
--
2.23.0

48
etmem.spec
View File

@ -2,7 +2,7 @@
Name: etmem
Version: 1.0
Release: 10
Release: 11
Summary: etmem
License: Mulan PSL v2
URL: https://gitee.com/openeuler/etmem
@ -59,6 +59,39 @@ Patch47: 0048-Commit-new-features-memRouter-and-userswap-to-etmem.patch
Patch48: 0049-Add-engine-memdcd-to-etmemd.patch
Patch49: 0050-Add-CMakeLists.txt-for-three-features-of-etmem.patch
Patch50: 0051-update-memdcd-engine-for-userswap.patch
Patch51: 0052-etmem-correct-example-config-file.patch
Patch52: 0053-etmem-split-example_conf.yaml.patch
Patch53: 0054-add-License-in-memRouter.patch
Patch54: 0055-add-code-of-testcase-for-etmem-common-function.patch
Patch55: 0056-add-code-of-testcase-for-etmem-project-function.patch
Patch56: 0057-add-test-for-export-scan.patch
Patch57: 0058-add-code-of-testcase-for-etmem-common-function.patch
Patch58: 0059-add-code-of-testcase-for-etmem-log-ops.patch
Patch59: 0060-add-make-install-support-to-CMakeList.patch
Patch60: 0061-add-region-scan.patch
Patch61: 0062-fix-etmem-build-problem.patch
Patch62: 0063-etmem-add-code-of-testcase.patch
Patch63: 0064-etmem-add-code-of-testcase.patch
Patch64: 0065-etmem-add-code-of-testcase.patch
Patch65: 0066-etmem-add-sysmem_threshold-and-swap_threshold-parame.patch
Patch66: 0067-etmem-add-swapcache-reclaim-to-etmem.patch
Patch67: 0068-etmem-add-swap-flag-to-support-specified-page-swap-o.patch
Patch68: 0069-etmem-fix-the-swapcache-wmark-configuration-parse-er.patch
Patch69: 0070-etmem-update-README.md.patch
Patch70: 0071-etmem-add-code-of-testcase.patch
Patch71: 0072-etmem-add-code-of-testcase.patch
Patch72: 0073-etmem-add-testcode-script.patch
Patch73: 0074-etmem-add-code-of-testcase.patch
Patch74: 0075-etmem-testcode-adaptation.patch
Patch75: 0076-cslide-limit-hot_threshold-range-to-avoid-overflow-a.patch
Patch76: 0077-etmem-fix-the-problem-of-libso-no-permission-verific.patch
Patch77: 0078-etmem-add-config-file-permission-check.patch
Patch78: 0079-etmem-fix-problem-of-abnormal-task-value.patch
Patch79: 0080-etmem-remove-useless-dt-test-code.patch
Patch80: 0081-etmem-Fix-help-command.patch
Patch81: 0082-etmem-add-etmem-project-License-and-notice-file.patch
Patch82: 0083-etmem-fix-memory-leak.patch
Patch83: 0084-etmem-add-dt-test-code-for-permission-check.patch
#Dependency
BuildRequires: cmake gcc gcc-c++ glib2-devel
@ -87,7 +120,10 @@ install -d $RPM_BUILD_ROOT%{_sysconfdir}/etmem/
install -m 0700 etmem/build/bin/etmem $RPM_BUILD_ROOT%{_bindir}
install -m 0700 etmem/build/bin/etmemd $RPM_BUILD_ROOT%{_bindir}
install -m 0600 etmem/conf/example_conf.yaml $RPM_BUILD_ROOT%{_sysconfdir}/etmem/
install -m 0600 etmem/conf/damon_conf.yaml $RPM_BUILD_ROOT%{_sysconfdir}/etmem/
install -m 0600 etmem/conf/cslide_conf.yaml $RPM_BUILD_ROOT%{_sysconfdir}/etmem/
install -m 0600 etmem/conf/slide_conf.yaml $RPM_BUILD_ROOT%{_sysconfdir}/etmem/
install -m 0600 etmem/conf/thirdparty_conf.yaml $RPM_BUILD_ROOT%{_sysconfdir}/etmem/
install -m 0750 build/memRouter/memdcd $RPM_BUILD_ROOT%{_bindir}
install -m 0750 build/userswap/libuswap.a $RPM_BUILD_ROOT%{_libdir}
@ -97,7 +133,10 @@ install -m 0644 userswap/include/uswap_api.h $RPM_BUILD_ROOT%{_includedir}
%attr(0500, -, -) %{_bindir}/etmem
%attr(0500, -, -) %{_bindir}/etmemd
%dir %{_sysconfdir}/etmem
%{_sysconfdir}/etmem/example_conf.yaml
%{_sysconfdir}/etmem/damon_conf.yaml
%{_sysconfdir}/etmem/cslide_conf.yaml
%{_sysconfdir}/etmem/slide_conf.yaml
%{_sysconfdir}/etmem/thirdparty_conf.yaml
%attr(0550, -, -) %{_bindir}/memdcd
%attr(0550, -, -) %{_libdir}/libuswap.a
%{_includedir}/uswap_api.h
@ -106,6 +145,9 @@ install -m 0644 userswap/include/uswap_api.h $RPM_BUILD_ROOT%{_includedir}
%postun -p /sbin/ldconfig
%changelog
* Mon Aug 1 2022 liubo <liubo254@huawei.com> 1.0-11
- Sync the features and bug fixes in the etmem source repo.
* Thu Dec 16 2021 YangXin <245051644@qq.com> 1.0-10
- Update memdcd engine for userswap page filter.