diff --git a/services/param/linux/param_service.c b/services/param/linux/param_service.c
index 3591e73b853bcd3a6f8cf7f4f8dfdf3aadc889b7..9332af772e72c2c43a30d465faf82b8715e0889c 100755
--- a/services/param/linux/param_service.c
+++ b/services/param/linux/param_service.c
@@ -161,8 +161,8 @@ static int SystemSetParam(const char *name, const char *value, const ParamSecuri
 static int SystemUpdateConstParamter(const char *name, const char *value, const ParamSecurityLabel *srcLabel)
 {
     PARAM_LOGV("SystemUpdateConstParam name %s value: %s", name, value);
-    int ctrlService = 0;
-    int ret = CheckParameterSet(name, value, srcLabel, &ctrlService);
+    uint32_t ctrlService = 0;
+    int ret = CheckParameterSet(name, value, srcLabel, (int *)&ctrlService);
     PARAM_CHECK(ret == 0, return ret, "Forbid to set parameter %s", name);
     PARAM_CHECK(IS_READY_ONLY(name), return PARAM_CODE_INVALID_NAME, "only update read only param: %s", name);
     if ((ctrlService & PARAM_CTRL_SERVICE) != PARAM_CTRL_SERVICE) { // ctrl param
diff --git a/test/moduletest/syspara.cpp b/test/moduletest/syspara.cpp
index bdae25c6ae0482216fd0d6378d4cf8298fcc9974..9aa733e5f2abd0f992fa5a1e11812f5b3070c1a8 100644
--- a/test/moduletest/syspara.cpp
+++ b/test/moduletest/syspara.cpp
@@ -24,35 +24,35 @@
 #include "sysversion.h"
 
 using SysParaInfoItem = struct {
-    char *infoName;
+    const char *infoName;
     const char *(*getInfoValue)(void);
 };
 
 static const SysParaInfoItem SYSPARA_LIST[] = {
-    {(char *)"DeviceType", GetDeviceType},
-    {(char *)"Manufacture", GetManufacture},
-    {(char *)"Brand", GetBrand},
-    {(char *)"MarketName", GetMarketName},
-    {(char *)"ProductSeries", GetProductSeries},
-    {(char *)"ProductModel", GetProductModel},
-    {(char *)"ProductModelAlias", GetProductModel},
-    {(char *)"SoftwareModel", GetSoftwareModel},
-    {(char *)"HardwareModel", GetHardwareModel},
-    {(char *)"Serial", GetSerial},
-    {(char *)"OSFullName", GetOSFullName},
-    {(char *)"DisplayVersion", GetDisplayVersion},
-    {(char *)"BootloaderVersion", GetBootloaderVersion},
-    {(char *)"GetSecurityPatchTag", GetSecurityPatchTag},
-    {(char *)"AbiList", GetAbiList},
-    {(char *)"IncrementalVersion", GetIncrementalVersion},
-    {(char *)"VersionId", GetVersionId},
-    {(char *)"BuildType", GetBuildType},
-    {(char *)"BuildUser", GetBuildUser},
-    {(char *)"BuildHost", GetBuildHost},
-    {(char *)"BuildTime", GetBuildTime},
-    {(char *)"BuildRootHash", GetBuildRootHash},
-    {(char *)"GetOsReleaseType", GetOsReleaseType},
-    {(char *)"GetHardwareProfile", GetHardwareProfile},
+    {"DeviceType", GetDeviceType},
+    {"Manufacture", GetManufacture},
+    {"Brand", GetBrand},
+    {"MarketName", GetMarketName},
+    {"ProductSeries", GetProductSeries},
+    {"ProductModel", GetProductModel},
+    {"ProductModelAlias", GetProductModel},
+    {"SoftwareModel", GetSoftwareModel},
+    {"HardwareModel", GetHardwareModel},
+    {"Serial", GetSerial},
+    {"OSFullName", GetOSFullName},
+    {"DisplayVersion", GetDisplayVersion},
+    {"BootloaderVersion", GetBootloaderVersion},
+    {"GetSecurityPatchTag", GetSecurityPatchTag},
+    {"AbiList", GetAbiList},
+    {"IncrementalVersion", GetIncrementalVersion},
+    {"VersionId", GetVersionId},
+    {"BuildType", GetBuildType},
+    {"BuildUser", GetBuildUser},
+    {"BuildHost", GetBuildHost},
+    {"BuildTime", GetBuildTime},
+    {"BuildRootHash", GetBuildRootHash},
+    {"GetOsReleaseType", GetOsReleaseType},
+    {"GetHardwareProfile", GetHardwareProfile},
 };
 
 static int32_t SysParaApiDumpCmd(BShellHandle shell, int32_t argc, char *argv[])
diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn
index 51192116318e5918ead865cdc062250c3b85a4d6..00e7d3bad317868a19446dce6a5ddc71fa983f42 100755
--- a/test/unittest/BUILD.gn
+++ b/test/unittest/BUILD.gn
@@ -183,6 +183,15 @@ ohos_unittest("init_unittest") {
   ]
   defines = []
 
+  sources += [
+    "//base/startup/init/interfaces/innerkits/fs_manager/libfs_dm/fs_dm.c",
+    "//base/startup/init/interfaces/innerkits/fs_manager/libfs_dm/fs_dm_linear.c",
+  ]
+  include_dirs += [
+    "//base/startup/init/interfaces/innerkits/fs_manager/libfs_dm",
+    "//base/startup/init/interfaces/innerkits/include/fs_manager",
+    "//base/startup/init/interfaces/innerkits/fs_manager/libfs_dm/include",
+  ]
   if (defined(build_seccomp) && build_seccomp) {
     sources += [
       "../../services/modules/seccomp/seccomp_policy.c",
@@ -327,8 +336,7 @@ ohos_unittest("init_unittest") {
   ]
   defines += [ "_GNU_SOURCE" ]
 
-  if (target_cpu == "arm64" || target_cpu == "x86_64" ||
-      target_cpu == "riscv64") {
+  if (target_cpu == "arm64" || target_cpu == "x86_64" ) {
     defines += [ "SUPPORT_64BIT" ]
   }
 
@@ -482,6 +490,7 @@ ohos_unittest("init_dmverify_unittest") {
     "hilog:libhilog",
   ]
 
+  defines = []
   if (defined(global_parts_info) && defined(global_parts_info.startup_hvb)) {
     external_deps += [ "hvb:libhvb_static" ]
     sources += [
@@ -508,6 +517,10 @@ ohos_unittest("init_fshvb_unittest") {
     "//base/startup/init/interfaces/innerkits/include/param",
   ]
 
+  deps = [
+    "//base/startup/init/interfaces/innerkits:libbegetutil",
+    "//base/startup/init/interfaces/innerkits/fs_manager:libfsmanager_static",
+  ]
   sources = [
     "//base/startup/init/interfaces/innerkits/fs_manager/fstab.c",
     "//base/startup/init/interfaces/innerkits/fs_manager/fstab_mount.c",
@@ -518,11 +531,6 @@ ohos_unittest("init_fshvb_unittest") {
     "//base/startup/init/test/mock/init/ueventd/ueventd_socket.c",
   ]
 
-  deps = [
-    "//base/startup/init/interfaces/innerkits:libbegetutil",
-    "//base/startup/init/interfaces/innerkits/fs_manager:libfsmanager_static",
-  ]
-
   defines = [ "STARTUP_INIT_UT_PATH =\"/data/init_ut\"" ]
 
   configs = []
diff --git a/test/unittest/begetctl/begetctl_unittest.cpp b/test/unittest/begetctl/begetctl_unittest.cpp
index 6c7b7a4d0ce7bddae4387f3779621a690af9b5e5..8e69c75b2ed8ea4274011dbd77f3b83a071faf0d 100644
--- a/test/unittest/begetctl/begetctl_unittest.cpp
+++ b/test/unittest/begetctl/begetctl_unittest.cpp
@@ -32,428 +32,459 @@ public:
 HWTEST_F(BegetctlUnitTest, Init_TestShellInit_001, TestSize.Level0)
 {
     BShellParamCmdRegister(GetShellHandle(), 0);
-    const char *args[] = {
-        "param"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), 1, const_cast<char **>(args));
+    char arg0[] = "param";
+    char* args[] = { arg0, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestShellLs_001, TestSize.Level1)
 {
     BShellParamCmdRegister(GetShellHandle(), 0);
-    const char *args[] = {
-        "param", "ls"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "param";
+    char arg1[] = "ls";
+    char* args[] = { arg0, arg1, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestShellLsWithR_001, TestSize.Level1)
 {
     BShellParamCmdRegister(GetShellHandle(), 0);
-    const char *args[] = {
-        "param", "ls", "-r"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "param";
+    char arg1[] = "ls";
+    char arg2[] = "-r";
+    char* args[] = { arg0, arg1, arg2, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestShellLsGet_001, TestSize.Level1)
 {
     BShellParamCmdRegister(GetShellHandle(), 0);
-    const char *args[] = {
-        "param", "get"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "param";
+    char arg1[] = "get";
+    char* args[] = { arg0, arg1, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestShellSet_001, TestSize.Level1)
 {
     BShellParamCmdRegister(GetShellHandle(), 0);
-    const char *args[] = {
-        "param", "set", "aaaaa", "1234567"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "param";
+    char arg1[] = "set";
+    char arg2[] = "aaaaa";
+    char arg3[] = "1234567";
+    char* args[] = { arg0, arg1, arg2, arg3, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestShellGetWithKey_001, TestSize.Level1)
 {
     BShellParamCmdRegister(GetShellHandle(), 0);
-    const char *args[] = {
-        "param", "get", "aaaaa"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "param";
+    char arg1[] = "get";
+    char arg2[] = "aaaaa";
+    char* args[] = { arg0, arg1, arg2, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestShellWait_001, TestSize.Level1)
 {
     BShellParamCmdRegister(GetShellHandle(), 0);
-    const char *args[] = {
-        "param", "wait", "aaaaa"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "param";
+    char arg1[] = "wait";
+    char arg2[] = "aaaaa";
+    char* args[] = { arg0, arg1, arg2, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
+
 HWTEST_F(BegetctlUnitTest, Init_TestShellWaitFalse_001, TestSize.Level1)
 {
     BShellParamCmdRegister(GetShellHandle(), 0);
-    const char *args[] = {
-        "param", "wait"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "param";
+    char arg1[] = "wait";
+    char* args[] = { arg0, arg1, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestShellWaitWithKey_001, TestSize.Level1)
 {
     BShellParamCmdRegister(GetShellHandle(), 0);
-    const char *args[] = {
-        "param", "wait", "aaaaa", "12*", "30"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "param";
+    char arg1[] = "wait";
+    char arg2[] = "aaaaa";
+    char arg3[] = "12*";
+    char arg4[] = "30";
+    char* args[] = { arg0, arg1, arg2, arg3, arg4, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
+
 HWTEST_F(BegetctlUnitTest, Init_TestShellParamShell_001, TestSize.Level1)
 {
     BShellParamCmdRegister(GetShellHandle(), 0);
-    const char *args[] = {
-        "param", "shell"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "param";
+    char arg1[] = "shell";
+    char* args[] = { arg0, arg1, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
+
 HWTEST_F(BegetctlUnitTest, Init_TestShellLsWithvalue_001, TestSize.Level1)
 {
     BShellParamCmdRegister(GetShellHandle(), 0);
     BShellEnvSetParam(GetShellHandle(), PARAM_REVERESD_NAME_CURR_PARAMETER, "..a", PARAM_STRING, (void *)"..a");
-    const char *args[] = {
-        "param", "ls", PARAM_REVERESD_NAME_CURR_PARAMETER
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "param";
+    char arg1[] = "ls";
+    char arg2[] = PARAM_REVERESD_NAME_CURR_PARAMETER;
+    char* args[] = { arg0, arg1, arg2, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
+
 HWTEST_F(BegetctlUnitTest, Init_TestShellLsWithvalueExist_001, TestSize.Level1)
 {
     BShellParamCmdRegister(GetShellHandle(), 0);
     BShellEnvSetParam(GetShellHandle(), PARAM_REVERESD_NAME_CURR_PARAMETER, "#", PARAM_STRING, (void *)"#");
-    const char *args[] = {
-        "param", "ls", "-r", PARAM_REVERESD_NAME_CURR_PARAMETER
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "param";
+    char arg1[] = "ls";
+    char arg2[] = "-r";
+    char arg3[] = PARAM_REVERESD_NAME_CURR_PARAMETER;
+    char* args[] = { arg0, arg1, arg2, arg3, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestPartitionSlot_001, TestSize.Level1)
 {
-    const char *args[] = {
-        "partitionslot", "getslot"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "partitionslot";
+    char arg1[] = "getslot";
+    char* args[] = { arg0, arg1, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestPartitionSlot_002, TestSize.Level1)
 {
-    const char *args[] = {
-        "partitionslot", "getsuffix", "1"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "partitionslot";
+    char arg1[] = "getsuffix";
+    char arg2[] = "1";
+    char* args[] = { arg0, arg1, arg2, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestPartitionSlot_003, TestSize.Level1)
 {
-    const char *args[] = {
-        "partitionslot", "setactive", "1"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "partitionslot";
+    char arg1[] = "setactive";
+    char arg2[] = "1";
+    char* args[] = { arg0, arg1, arg2, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestPartitionSlot_004, TestSize.Level1)
 {
-    const char *args[] = {
-        "partitionslot", "setunboot", "2"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "partitionslot";
+    char arg1[] = "setunboot";
+    char arg2[] = "2";
+    char* args[] = { arg0, arg1, arg2, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestPartitionSlot_005, TestSize.Level1)
 {
-    const char *args[] = {
-        "partitionslot", "setactive"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "partitionslot";
+    char arg1[] = "setactive";
+    char* args[] = { arg0, arg1, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestPartitionSlot_006, TestSize.Level1)
 {
-    const char *args[] = {
-        "partitionslot", "setunboot"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "partitionslot";
+    char arg1[] = "setunboot";
+    char* args[] = { arg0, arg1, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestPartitionSlot_007, TestSize.Level1)
 {
-    const char *args[] = {
-        "partitionslot", "getsuffix"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "partitionslot";
+    char arg1[] = "getsuffix";
+    char* args[] = { arg0, arg1, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestShellLog_001, TestSize.Level1)
 {
-    const char *args[] = {
-        "set", "log", "level", "1"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "set";
+    char arg1[] = "log";
+    char arg2[] = "level";
+    char arg3[] = "1";
+    char* args[] = { arg0, arg1, arg2, arg3, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestShellLog_002, TestSize.Level1)
 {
-    const char *args[] = {
-        "get", "log", "level"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "get";
+    char arg1[] = "log";
+    char arg2[] = "level";
+    char* args[] = { arg0, arg1, arg2, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestShellLog_003, TestSize.Level1)
 {
-    const char *args[] = {
-        "set", "log", "level"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "set";
+    char arg1[] = "log";
+    char arg2[] = "level";
+    char* args[] = { arg0, arg1, arg2, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestShellLog_004, TestSize.Level1)
 {
-    const char *args[] = {
-        "set", "log", "level", "1000"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "set";
+    char arg1[] = "log";
+    char arg2[] = "level";
+    char arg3[] = "1000";
+    char* args[] = { arg0, arg1, arg2, arg3, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestShellLog_005, TestSize.Level1)
 {
-    const char *args[] = {
-        "set", "log", "level", "a"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "set";
+    char arg1[] = "log";
+    char arg2[] = "level";
+    char arg3[] = "a";
+    char* args[] = { arg0, arg1, arg2, arg3, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestBootChart_001, TestSize.Level1)
 {
-    const char *args[] = {
-        "bootchart", "enable"
-    };
+    char arg0[] = "bootchart";
+    char arg1[] = "enable";
+    char* args[] = { arg0, arg1, nullptr };
     SystemWriteParam("persist.init.bootchart.enabled", "1");
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestBootChart_002, TestSize.Level1)
 {
-    const char *args[] = {
-        "bootchart", "start"
-    };
-
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "bootchart";
+    char arg1[] = "start";
+    char* args[] = { arg0, arg1, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestBootChart_003, TestSize.Level1)
 {
-    const char *args[] = {
-        "bootchart", "stop"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "bootchart";
+    char arg1[] = "stop";
+    char* args[] = { arg0, arg1, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestBootChart_004, TestSize.Level1)
 {
-    const char *args[] = {
-        "bootchart", "disable"
-    };
+    char arg0[] = "bootchart";
+    char arg1[] = "disable";
+    char* args[] = { arg0, arg1, nullptr };
     SystemWriteParam("persist.init.bootchart.enabled", "0");
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestBootChart_005, TestSize.Level1)
 {
-    const char *args[] = {
-        "bootchart"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "bootchart";
+    char* args[] = { arg0, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestDumpService_001, TestSize.Level1)
 {
-    const char *args[] = {
-        "bootevent", "enable"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "bootevent";
+    char arg1[] = "enable";
+    char* args[] = { arg0, arg1, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestDumpService_002, TestSize.Level1)
 {
-    const char *args[] = {
-        "bootevent", "disable"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "bootevent";
+    char arg1[] = "disable";
+    char* args[] = { arg0, arg1, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestDumpService_003, TestSize.Level1)
 {
-    const char *args[] = {
-        "dump_service", "all"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "dump_service";
+    char arg1[] = "all";
+    char* args[] = { arg0, arg1, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestDumpService_004, TestSize.Level1)
 {
-    const char *args[] = {
-        "dump_service", "param_watcher"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "dump_service";
+    char arg1[] = "param_watcher";
+    char* args[] = { arg0, arg1, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestDumpService_005, TestSize.Level1)
 {
-    const char *args[] = {
-        "dump_service", "parameter-service", "trigger"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "dump_service";
+    char arg1[] = "parameter-service";
+    char arg2[] = "trigger";
+    char* args[] = { arg0, arg1, arg2, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestDumpNwebSpawn_001, TestSize.Level1)
 {
-    const char *args[] = {
-        "dump_nwebspawn", ""
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "dump_nwebspawn";
+    char arg1[] = "";
+    char* args[] = { arg0, arg1, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestDumpAppspawn_001, TestSize.Level1)
 {
-    const char *args[] = {
-        "dump_appspawn", ""
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "dump_appspawn";
+    char arg1[] = "";
+    char* args[] = { arg0, arg1, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestMiscDaemon_001, TestSize.Level1)
 {
-    const char *args[] = {
-        "misc_daemon", "--write_logo", BOOT_CMD_LINE
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "misc_daemon";
+    char arg1[] = "--write_logo";
+    char arg2[] = BOOT_CMD_LINE;
+    char* args[] = { arg0, arg1, arg2, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestMiscDaemon_002, TestSize.Level1)
 {
-    const char *args[] = {
-        "misc_daemon", "--write_logo1111", "test"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "misc_daemon";
+    char arg1[] = "--write_logo1111";
+    char arg2[] = "test";
+    char* args[] = { arg0, arg1, arg2, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestMiscDaemon_003, TestSize.Level1)
 {
-    const char *args[] = {
-        "misc_daemon", "--write_logo", ""
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "misc_daemon";
+    char arg1[] = "--write_logo";
+    char arg2[] = "";
+    char* args[] = { arg0, arg1, arg2, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestMiscDaemon_004, TestSize.Level1)
 {
-    const char *args[] = {
-        "misc_daemon", "--write_logo"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "misc_daemon";
+    char arg1[] = "--write_logo";
+    char* args[] = { arg0, arg1, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestMiscDaemon_005, TestSize.Level1)
 {
     // clear misc logo
-    const char *args[] = {
-        "misc_daemon", "--write_logo", "sssssssss"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "misc_daemon";
+    char arg1[] = "--write_logo";
+    char arg2[] = "sssssssss";
+    char* args[] = { arg0, arg1, arg2, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestModulectl_001, TestSize.Level1)
 {
-    const char *args[] = {
-        "modulectl", "install", "testModule"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "modulectl";
+    char arg1[] = "install";
+    char arg2[] = "testModule";
+    char* args[] = { arg0, arg1, arg2, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestModulectl_002, TestSize.Level1)
 {
-    const char *args[] = {
-        "modulectl", "uninstall", "testModule"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "modulectl";
+    char arg1[] = "uninstall";
+    char arg2[] = "testModule";
+    char* args[] = { arg0, arg1, arg2, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestModulectl_003, TestSize.Level1)
 {
-    const char *args[] = {
-        "modulectl", "list", "testModule"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "modulectl";
+    char arg1[] = "list";
+    char arg2[] = "testModule";
+    char* args[] = { arg0, arg1, arg2, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestModulectl_004, TestSize.Level1)
 {
-    const char *args[] = {
-        "modulectl", "install"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "modulectl";
+    char arg1[] = "install";
+    char* args[] = { arg0, arg1, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestModulectl_005, TestSize.Level1)
 {
-    const char *args[] = {
-        "modulectl", "list"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "modulectl";
+    char arg1[] = "list";
+    char* args[] = { arg0, arg1, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
@@ -465,271 +496,281 @@ HWTEST_F(BegetctlUnitTest, Init_TestModulectl_006, TestSize.Level1)
 
 HWTEST_F(BegetctlUnitTest, Init_TestServiceControl_001, TestSize.Level1)
 {
-    const char *args[] = {
-        "service_control", "stop", "test"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "service_control";
+    char arg1[] = "stop";
+    char arg2[] = "test";
+    char* args[] = { arg0, arg1, arg2, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestServiceControl_002, TestSize.Level1)
 {
-    const char *args[] = {
-        "service_control", "start", "test"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "service_control";
+    char arg1[] = "start";
+    char arg2[] = "test";
+    char* args[] = { arg0, arg1, arg2, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestServiceControl_003, TestSize.Level1)
 {
-    const char *args[] = {
-        "stop_service", "test"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "stop_service";
+    char arg1[] = "test";
+    char* args[] = { arg0, arg1, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestServiceControl_004, TestSize.Level1)
 {
-    const char *args[] = {
-        "start_service", "test"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "start_service";
+    char arg1[] = "test";
+    char* args[] = { arg0, arg1, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestServiceControl_005, TestSize.Level1)
 {
-    const char *args[] = {
-        "timer_stop", "test"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "timer_stop";
+    char arg1[] = "test";
+    char* args[] = { arg0, arg1, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestServiceControl_006, TestSize.Level1)
 {
-    const char *args[] = {
-        "timer_stop"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "timer_stop";
+    char* args[] = { arg0, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestServiceControl_007, TestSize.Level1)
 {
-    const char *args[] = {
-        "timer_start", "test-service", "10"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "timer_start";
+    char arg1[] = "test-service";
+    char arg2[] = "10";
+    char* args[] = { arg0, arg1, arg2, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestServiceControl_008, TestSize.Level1)
 {
-    const char *args[] = {
-        "timer_start", "test-service",
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "timer_start";
+    char arg1[] = "test-service";
+    char* args[] = { arg0, arg1, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestServiceControl_009, TestSize.Level1)
 {
-    const char *args[] = {
-        "timer_start", "test-service", "ww"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "timer_start";
+    char arg1[] = "test-service";
+    char arg2[] = "ww";
+    char* args[] = { arg0, arg1, arg2, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestServiceControl_010, TestSize.Level1)
 {
-    const char *args[] = {
-        "xxxxxxxxxxxxxx", "test-service", "ww"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "xxxxxxxxxxxxxx";
+    char arg1[] = "test-service";
+    char arg2[] = "ww";
+    char* args[] = { arg0, arg1, arg2, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestSetLogLevel_001, TestSize.Level1)
 {
-    const char *args[] = {
-        "setloglevel", "1"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "setloglevel";
+    char arg1[] = "1";
+    char* args[] = { arg0, arg1, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestSetLogLevel_002, TestSize.Level1)
 {
-    const char *args[] = {
-        "getloglevel"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "getloglevel";
+    char* args[] = { arg0, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestSetLogLevel_003, TestSize.Level1)
 {
-    const char *args[] = {
-        "setloglevel", "a"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "setloglevel";
+    char arg1[] = "a";
+    char* args[] = { arg0, arg1, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestSetLogLevel_004, TestSize.Level1)
 {
-    const char *args[] = {
-        "setloglevel"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "setloglevel";
+    char* args[] = { arg0, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestSetLogLevel_005, TestSize.Level1)
 {
-    const char *args[] = {
-        "setloglevel"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), 0, const_cast<char **>(args));
+    char arg0[] = "setloglevel";
+    char* args[] = { arg0, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), 0, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestSandbox_001, TestSize.Level1)
 {
-    const char *args[] = {
-        "sandbox", "-s", "test", "-n", "test2", "-p", "test3", "-h", "?"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "sandbox";
+    char arg1[] = "-s";
+    char arg2[] = "test";
+    char arg3[] = "-n";
+    char arg4[] = "test2";
+    char arg5[] = "-p";
+    char arg6[] = "test3";
+    char arg7[] = "-h";
+    char arg8[] = "?";
+    char* args[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestSandbox_002, TestSize.Level1)
 {
-    const char *args[] = {
-        "sandbox", "-b", "1008"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "sandbox";
+    char arg1[] = "-b";
+    char arg2[] = "1008";
+    char* args[] = { arg0, arg1, arg2, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestReboot_001, TestSize.Level1)
 {
-    const char *args[] = {
-        "reboot"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "reboot";
+    char* args[] = { arg0, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestReboot_002, TestSize.Level1)
 {
-    const char *args[] = {
-        "reboot", "shutdown"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "reboot";
+    char arg1[] = "shutdown";
+    char* args[] = { arg0, arg1, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestReboot_003, TestSize.Level1)
 {
-    const char *args[] = {
-        "reboot", "charge"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "reboot";
+    char arg1[] = "charge";
+    char* args[] = { arg0, arg1, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestReboot_004, TestSize.Level1)
 {
-    const char *args[] = {
-        "reboot", "updater"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "reboot";
+    char arg1[] = "updater";
+    char* args[] = { arg0, arg1, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestReboot_005, TestSize.Level1)
 {
-    const char *args[] = {
-        "reboot", "updater:aaaaaaa"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "reboot";
+    char arg1[] = "updater:aaaaaaa";
+    char* args[] = { arg0, arg1, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestReboot_006, TestSize.Level1)
 {
-    const char *args[] = {
-        "reboot", "flashd:aaaaaaa"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "reboot";
+    char arg1[] = "flashd:aaaaaaa";
+    char* args[] = { arg0, arg1, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestReboot_007, TestSize.Level1)
 {
-    const char *args[] = {
-        "reboot", "flashd"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "reboot";
+    char arg1[] = "flashd";
+    char* args[] = { arg0, arg1, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestReboot_008, TestSize.Level1)
 {
-    const char *args[] = {
-        "reboot", "suspend"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "reboot";
+    char arg1[] = "suspend";
+    char* args[] = { arg0, arg1, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestReboot_009, TestSize.Level1)
 {
-    const char *args[] = {
-        "reboot", "222222222"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "reboot";
+    char arg1[] = "222222222";
+    char* args[] = { arg0, arg1, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestGid_001, TestSize.Level1)
 {
-    const char *args[] = {
-        "dac", "gid", "logd"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "dac";
+    char arg1[] = "gid";
+    char arg2[] = "logd";
+    char* args[] = { arg0, arg1, arg2, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestGid_002, TestSize.Level1)
 {
-    const char *args[] = {
-        "dac"
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "dac";
+    char* args[] = { arg0, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestUid_001, TestSize.Level1)
 {
-    const char *args[] = {
-        "dac", "uid", ""
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "dac";
+    char arg1[] = "uid";
+    char arg2[] = "";
+    char* args[] = { arg0, arg1, arg2, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 
 HWTEST_F(BegetctlUnitTest, Init_TestUid_002, TestSize.Level1)
 {
-    const char *args[] = {
-        "dac", "uid", ""
-    };
-    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
+    char arg0[] = "dac";
+    char arg1[] = "uid";
+    char arg2[] = "";
+    char* args[] = { arg0, arg1, arg2, nullptr };
+    int ret = BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]) - 1, args);
     EXPECT_EQ(ret, 0);
 }
 }  // namespace init_ut
diff --git a/test/unittest/fs_manager/dm_verify/dm_verify_unittest.cpp b/test/unittest/fs_manager/dm_verify/dm_verify_unittest.cpp
index 8288cdc4915c251202d136c45d7ef71362c29787..83c1a0d87b445bf63a2f4b9d0e876938dcea84af 100644
--- a/test/unittest/fs_manager/dm_verify/dm_verify_unittest.cpp
+++ b/test/unittest/fs_manager/dm_verify/dm_verify_unittest.cpp
@@ -24,8 +24,6 @@ class DmVerifyUnitTest : public testing::Test {
 public:
     static void SetUpTestCase(void) {};
     static void TearDownTestCase(void) {};
-    void SetUp(void) {};
-    void TearDown(void) {};
 };
 
 static int TestHvbDmVerityFinal(void)
@@ -37,8 +35,14 @@ static int TestHvbDmVerityFinal(void)
 HWTEST_F(DmVerifyUnitTest, HvbDmVerityinit_001, TestSize.Level0)
 {
     int ret;
-    FstabItem fstabitem = {(char *)"deviceName", (char *)"mountPoint",
-        (char *)"fsType", (char *)"mountOptions", 1, nullptr};
+    FstabItem fstabitem;
+    char testStr[10] = "testStr";
+    fstabitem.deviceName = testStr;
+    fstabitem.mountPoint = testStr;
+    fstabitem.fsType = testStr;
+    fstabitem.mountOptions = testStr;
+    fstabitem.fsManagerFlags = 1;
+    fstabitem.next = nullptr;
     Fstab fstab = {&fstabitem};
 
     ret = HvbDmVerityinit(&fstab);
@@ -70,8 +74,14 @@ HWTEST_F(DmVerifyUnitTest, HvbDmVerityinit_001, TestSize.Level0)
 HWTEST_F(DmVerifyUnitTest, HvbDmVerityinit_002, TestSize.Level0)
 {
     int ret;
-    FstabItem fstabitem = {(char *)"deviceName", (char *)"mountPoint",
-        (char *)"fsType", (char *)"mountOptions", 1, nullptr};
+    FstabItem fstabitem;
+    char testStr[10] = "testStr";
+    fstabitem.deviceName = testStr;
+    fstabitem.mountPoint = testStr;
+    fstabitem.fsType = testStr;
+    fstabitem.mountOptions = testStr;
+    fstabitem.fsManagerFlags = 1;
+    fstabitem.next = nullptr;
     Fstab fstab = {&fstabitem};
 
     ret = HvbDmVerityinit(&fstab);
@@ -96,8 +106,14 @@ HWTEST_F(DmVerifyUnitTest, HvbDmVerityinit_002, TestSize.Level0)
 HWTEST_F(DmVerifyUnitTest, HvbDmVeritySetUp_001, TestSize.Level0)
 {
     int ret;
-    FstabItem fstabitem = {(char *)"deviceName", (char *)"mountPoint",
-        (char *)"fsType", (char *)"mountOptions", 1, nullptr};
+    FstabItem fstabitem;
+    char testStr[10] = "testStr";
+    fstabitem.deviceName = testStr;
+    fstabitem.mountPoint = testStr;
+    fstabitem.fsType = testStr;
+    fstabitem.mountOptions = testStr;
+    fstabitem.fsManagerFlags = 1;
+    fstabitem.next = nullptr;
 
     ret = HvbDmVeritySetUp(&fstabitem);
     EXPECT_EQ(ret, 0);
diff --git a/test/unittest/fs_manager/erofs/erofs_common_unittest.cpp b/test/unittest/fs_manager/erofs/erofs_common_unittest.cpp
index 28a5c624c3acce9c1ba4b77bb40cebdc75b39530..f01abbf43d06858842dd43ed25f9113182473b3b 100644
--- a/test/unittest/fs_manager/erofs/erofs_common_unittest.cpp
+++ b/test/unittest/fs_manager/erofs/erofs_common_unittest.cpp
@@ -55,7 +55,7 @@ HWTEST_F(ErofsCommonOverlayUnitTest, Init_IsOverlayEnable_001, TestSize.Level0)
     CreateTestFile(BOOT_CMD_LINE, cmdLine);
     ret = IsOverlayEnable();
     EXPECT_EQ(ret, true);
-    ret = remove(BOOT_CMD_LINE);
+    remove(BOOT_CMD_LINE);
     PrepareCmdLineData();
 }
 
diff --git a/test/unittest/fs_manager/libfs_hvb_unittest.cpp b/test/unittest/fs_manager/libfs_hvb_unittest.cpp
index ecc821a08f4892b7ee324b5f63677e81b9071c5f..d0ad7b07c487b644e0fbb402cceb0f54ec81ae78 100644
--- a/test/unittest/fs_manager/libfs_hvb_unittest.cpp
+++ b/test/unittest/fs_manager/libfs_hvb_unittest.cpp
@@ -29,8 +29,6 @@ class FsHvbUnitTest : public testing::Test {
 public:
     static void SetUpTestCase(void) {};
     static void TearDownTestCase(void) {};
-    void SetUp(void) {};
-    void TearDown(void) {};
 };
 
 void CreateTestFile(const char *fileName, const char *data)
diff --git a/test/unittest/init/init_unittest.cpp b/test/unittest/init/init_unittest.cpp
index da6df4193fe7354350de785572cab0a1448e2718..30db2bcbee187bad72389abea02aa70f1eb296e8 100644
--- a/test/unittest/init/init_unittest.cpp
+++ b/test/unittest/init/init_unittest.cpp
@@ -37,6 +37,7 @@
 #include "fd_holder_service.h"
 #include "bootstage.h"
 #include "parameter.h"
+#include "fs_dm_linear.h"
 
 using namespace testing::ext;
 using namespace std;
@@ -162,9 +163,31 @@ HWTEST_F(InitUnitTest, TestParseCfgByPriority, TestSize.Level1)
     int ret = 0;
     ret = ParseCfgByPriority(NULL);
     EXPECT_EQ(ret, -1);
-    ret = ParseCfgByPriority("etc/abcdtest");
-    EXPECT_EQ(ret, -1);
     ret = ParseCfgByPriority("etc/init");
     EXPECT_EQ(ret, 0);
 }
+
+HWTEST_F(InitUnitTest, FsDmCreateMultiTargetLinearDevice, TestSize.Level1)
+{
+    const char *devName = "testDevice";
+    char dmDevPath[256] = "/dev/mapper/testDevice";
+    uint64_t dmDevPathLen = sizeof(dmDevPath);
+
+    DmLinearTarget targets[2];
+    uint32_t targetNum = 2;
+
+    targets[0].start = 0;
+    targets[0].length = 100;
+    targets[0].paras_len = strlen("linear /dev/sda 0") + 1;
+    targets[0].paras = const_cast<char*>("linear /dev/sda 0");
+
+    targets[1].start = 100;
+    targets[1].length = 200;
+    targets[1].paras_len = strlen("linear /dev/sdb 0") + 1;
+
+    int fd = open("/dev/null", O_RDWR);
+    int rc = FsDmCreateMultiTargetLinearDevice(devName, dmDevPath, dmDevPathLen, targets, targetNum);
+    EXPECT_EQ(rc, -1);
+    close(fd);
+}
 }
diff --git a/test/unittest/lite/BUILD.gn b/test/unittest/lite/BUILD.gn
index 1f92813719f0480b5cf98804245d68cefbbd1fc7..2df7abe93765bbb48794fbbca8112f0d3cda9efe 100755
--- a/test/unittest/lite/BUILD.gn
+++ b/test/unittest/lite/BUILD.gn
@@ -248,7 +248,7 @@ if (defined(ohos_lite)) {
         "//base/startup/init/services/loopevent:loopevent",
         "//build/lite/config/component/cJSON:cjson_static",
       ]
-      external_deps += [ "mbedtls:mbedtls_static" ]
+      external_deps += [ "mbedtls:mbedtls_shared" ]
     }
   }
 }
diff --git a/test/unittest/param/watcher_proxy_unittest.cpp b/test/unittest/param/watcher_proxy_unittest.cpp
index c4e51377104c7ba40030d5092f521fdcb303ac44..08534aa316c9d25f04f4462bad4e1d9ae6d70d49 100644
--- a/test/unittest/param/watcher_proxy_unittest.cpp
+++ b/test/unittest/param/watcher_proxy_unittest.cpp
@@ -372,8 +372,6 @@ HWTEST_F(WatcherProxyUnitTest, Init_TestStop_001, TestSize.Level0)
 {
     WatcherProxyUnitTest test;
     uint32_t watcherId = 0;
-    fdsan_set_error_level(FDSAN_ERROR_LEVEL_DISABLED);
-
     test.TestAddRemoteWatcher(getpid(), watcherId);
     test.TestAddWatcher("test.permission.watcher.stop", watcherId);
     test.TestStop();
diff --git a/test/unittest/remount/remount_overlay_unittest.cpp b/test/unittest/remount/remount_overlay_unittest.cpp
index b6836381bfec128b53ba99c37bb449c086d26fa3..c43ac08f15c82ea7d2abb301ceca21f88b64bed0 100644
--- a/test/unittest/remount/remount_overlay_unittest.cpp
+++ b/test/unittest/remount/remount_overlay_unittest.cpp
@@ -47,32 +47,32 @@ HWTEST_F(RemountOverlayUnitTest, Init_IsSkipRemountTest_001, TestSize.Level0)
     bool ret = IsSkipRemount(mentry);
     EXPECT_EQ(ret, true);
 
-    char str1[] = "ufs";
-    char str2[] = "test";
-    mentry.mnt_type = str1;
-    mentry.mnt_dir = str2;
+    char ufs[] = "ufs";
+    char test[] = "test";
+    mentry.mnt_type = ufs;
+    mentry.mnt_dir = test;
     ret = IsSkipRemount(mentry);
     EXPECT_EQ(ret, true);
 
-    char str3[] = "/";
-    mentry.mnt_dir = str3;
+    char root[] = "/";
+    mentry.mnt_dir = root;
     ret = IsSkipRemount(mentry);
     EXPECT_EQ(ret, true);
 
-    char str4[] = "er11ofs";
-    mentry.mnt_type = str4;
+    char erofs1[] = "er11ofs";
+    mentry.mnt_type = erofs1;
     ret = IsSkipRemount(mentry);
     EXPECT_EQ(ret, true);
 
-    char str5[] = "erofs";
-    char str6[] = "/dev/block/ndm-";
-    mentry.mnt_type = str5;
-    mentry.mnt_fsname = str6;
+    char erofs[] = "erofs";
+    char ndm[] = "/dev/block/ndm-";
+    mentry.mnt_type = erofs;
+    mentry.mnt_fsname = ndm;
     ret = IsSkipRemount(mentry);
     EXPECT_EQ(ret, true);
 
-    char str7[] = "/dev/block/dm-1";
-    mentry.mnt_fsname = str7;
+    char dm1[] = "/dev/block/dm-1";
+    mentry.mnt_fsname = dm1;
     ret = IsSkipRemount(mentry);
     EXPECT_EQ(ret, false);
 }
@@ -83,14 +83,14 @@ HWTEST_F(RemountOverlayUnitTest, Init_ExecCommand_001, TestSize.Level0)
     int result = ExecCommand(0, nullArgv);
     EXPECT_NE(result, 0);  // Expect success
 
-    char *validArgv[] = {new char[strlen("/bin/ls") + 1], NULL};  // A valid command
+    const char *valid = "/bin/ls";
+    char *validArgv[] = {const_cast<char*>(valid), NULL};  // A valid command
     result = ExecCommand(1, validArgv);
     EXPECT_NE(result, 0);  // Expect success
 
-    char *invalidArgv[] = {new char[strlen("/notexit/ls") + 1], NULL};  // A valid command
+    const char *invalid = "/notexit/ls";
+    char *invalidArgv[] = {const_cast<char*>(invalid), NULL};  // A valid command
     result = ExecCommand(1, invalidArgv);
-    delete[] validArgv[0];
-    delete[] invalidArgv[0];
     EXPECT_NE(result, 0);  // Expect success
 }
 
diff --git a/test/unittest/seccomp/seccomp_unittest.cpp b/test/unittest/seccomp/seccomp_unittest.cpp
index 46a99e956fbd67f8416c71078a0114288ffea0fb..b1e79fd77d0ad6870a5ecd1fd558ab19ab9e305c 100644
--- a/test/unittest/seccomp/seccomp_unittest.cpp
+++ b/test/unittest/seccomp/seccomp_unittest.cpp
@@ -755,11 +755,11 @@ public:
     void TestSeccompCustomSyscall()
     {
         // app custom allowlist
-        ret = CheckSyscall(APP, APP_CUSTOM, CheckGetpid, true);
+        int ret = CheckSyscall(APP, APP_CUSTOM, CheckGetpid, true);
         EXPECT_EQ(ret, 0);
 
         // app custom blocklist
-        int ret = CheckSyscall(APP, APP_CUSTOM, CheckSetuid, false);
+        ret = CheckSyscall(APP, APP_CUSTOM, CheckSetuid, false);
         EXPECT_EQ(ret, 0);
     }
 #endif
diff --git a/test/unittest/syspara/syspara_unittest.cpp b/test/unittest/syspara/syspara_unittest.cpp
index a7735c558ec1a8ed846f6478811a2bb5474d492a..aef246ede8f5168ad11efc168d3cef25a9ab36a4 100644
--- a/test/unittest/syspara/syspara_unittest.cpp
+++ b/test/unittest/syspara/syspara_unittest.cpp
@@ -448,7 +448,7 @@ HWTEST_F(SysparaUnitTest, parameterTest0017, TestSize.Level0)
     EXPECT_GT(GetDistributionOSApiVersion(), 0);
     printf("distributionOS name =%s\n", GetDistributionOSReleaseType());
     EXPECT_STRNE(GetDistributionOSReleaseType(), nullptr);
-    printf("distributionOS name =%s\n", GetDistributionOSApiName());
+    printf("distributionOS api name =%s\n", GetDistributionOSApiName());
     printf("PerformanceClassLevel =%d\n", GetPerformanceClass());
     EXPECT_GE(GetPerformanceClass(), 0);
     EXPECT_LE(GetPerformanceClass(), 2);
diff --git a/ueventd/BUILD.gn b/ueventd/BUILD.gn
index aa7b8c1d4ed400242147784abd02219fab5c0ddf..ff1fe68212c1151cd72af86fe2b367d93e6869e7 100644
--- a/ueventd/BUILD.gn
+++ b/ueventd/BUILD.gn
@@ -13,6 +13,9 @@
 import("//base/startup/init/begetd.gni")
 
 if (defined(ohos_lite)) {
+  group("libueventd_ramdisk_static_real") {
+
+  }
   if (ohos_kernel_type == "linux") {
     service_ueventd_deps = [
       "//base/startup/init/interfaces/innerkits/socket:libsocket",
diff --git a/ueventd/include/ueventd.h b/ueventd/include/ueventd.h
index 51cb67cc84dff2e23e5c4c33882cc6c88cab17a7..017486112dfce1899f9082f304669d2d7a8fdaae 100644
--- a/ueventd/include/ueventd.h
+++ b/ueventd/include/ueventd.h
@@ -71,7 +71,7 @@ typedef enum SUBYSTEM {
 #define UEVENTD_FLAG "/dev/.ueventd_trigger_done"
 
 extern char bootDevice[CMDLINE_VALUE_LEN_MAX];
-typedef int (* CompareUevent)(struct Uevent *event);
+typedef int (* CompareUevent)(struct Uevent *uevent);
 const char *ActionString(ACTION action);
 void ParseUeventMessage(const char *buffer, ssize_t length, struct Uevent *uevent);
 void RetriggerUevent(int sockFd, char **devices, int num);
diff --git a/ueventd/ueventd.c b/ueventd/ueventd.c
index 046c2d4798d986521624f0eac27bdf5c5a1d3e62..5c8f78e33847e11afc8ed711481615e470034a2e 100644
--- a/ueventd/ueventd.c
+++ b/ueventd/ueventd.c
@@ -144,7 +144,7 @@ static void HandleRequiredDynamicDeviceNodes(const struct Uevent *uevent)
     mode_t mask;
     size_t idx = 0;
 
-    if (uevent->deviceName == NULL) {
+    if (uevent->deviceName == NULL || uevent->major < 0 || uevent->minor < 0) {
         return;
     }
 
@@ -171,6 +171,11 @@ static void HandleRequiredDynamicDeviceNodes(const struct Uevent *uevent)
     }
 }
 
+static bool IsPatchPartitionName(const char *partitionName)
+{
+    return strcmp(partitionName, "patch_a") == 0 || strcmp(partitionName, "patch_b") == 0;
+}
+
 static void HandleRequiredBlockDeviceNodes(const struct Uevent *uevent, char **devices, int num)
 {
     for (int i = 0; i < num; i++) {
@@ -188,9 +193,8 @@ static void HandleRequiredBlockDeviceNodes(const struct Uevent *uevent, char **d
             strstr(uevent->partitionName, "ramdisk") != NULL ||
             strstr(uevent->partitionName, "rvt") != NULL ||
             strstr(uevent->partitionName, "dtbo") != NULL ||
-            strstr(uevent->partitionName, "modem") != NULL ||
-            strcmp(uevent->partitionName, "patch_a") == 0 ||
-            strcmp(uevent->partitionName, "patch_b") == 0) {
+            strstr(uevent->partitionName, "modem_driver") != NULL ||
+            IsPatchPartitionName(uevent->partitionName)) {
             INIT_LOGI("Handle required partitionName %s", uevent->partitionName);
             HandleBlockDeviceEvent(uevent);
             return;
@@ -302,6 +306,7 @@ void ProcessUevent(int sockFd, char **devices, int num, CompareUevent compare)
             return;
         }
         if (compare != NULL) {
+            INIT_LOGV("find compare and do it");
             int ret = compare(&uevent);
             INIT_CHECK(ret == 0, return);
         }
diff --git a/ueventd/ueventd_device_handler.c b/ueventd/ueventd_device_handler.c
index df3c0ee0e7cd1f593404a7b42698c853418b7321..ec63752d658ecee800b3358f3e87fa8df2154d09 100644
--- a/ueventd/ueventd_device_handler.c
+++ b/ueventd/ueventd_device_handler.c
@@ -157,9 +157,7 @@ static int CreateDeviceNodeWithPermissions(const struct Uevent *uevent, const ch
     mode |= isBlock ? S_IFBLK : S_IFCHR;
     dev_t dev = makedev((unsigned int)major, (unsigned int)minor);
 
-    if (setegid(gid) != 0) {
-        INIT_LOGW("Failed to setegid %u, deviceNode: \" %s \" , errno %d", gid, deviceNode, errno);
-    }
+    (void)setegid(gid);
     mode_t originalMask = umask(000);
     int rc = mknod(deviceNode, mode, dev);
     (void)umask(originalMask);
@@ -168,9 +166,7 @@ static int CreateDeviceNodeWithPermissions(const struct Uevent *uevent, const ch
         return rc;
     }
     AdjustDeviceNodePermissions(deviceNode, uid, gid, mode);
-    if (setegid(0) != 0) {
-        INIT_LOGW("Failed to setegid 0, deviceNode: \" %s \" , errno %d", deviceNode, errno);
-    }
+    (void)setegid(0);
     return 0;
 }
 
diff --git a/ueventd/ueventd_main.c b/ueventd/ueventd_main.c
index 143496bfce17ce8fd4dbb4e1cee36c1d41b1977a..ba3f2f7e77b40b4b2bb1ed4b666c64b9b77fbc37 100644
--- a/ueventd/ueventd_main.c
+++ b/ueventd/ueventd_main.c
@@ -74,7 +74,8 @@ static void PollUeventdSocketTimeout(int ueventSockFd, bool ondemand)
 
 static int UeventdRetrigger(void)
 {
-    const char *ueventdConfigs[] = {"/etc/ueventd.config", "/vendor/etc/ueventd.config", NULL};
+    const char *ueventdConfigs[] = {"/etc/ueventd.config", "/vendor/etc/ueventd.config",
+        "/vendor/etc/ueventd_factory.config", NULL};
     int i = 0;
     while (ueventdConfigs[i] != NULL) {
         ParseUeventdConfigFile(ueventdConfigs[i++]);
@@ -92,7 +93,8 @@ static int UeventdDaemon(int listen_only)
 {
     // start log
     EnableInitLog(INIT_INFO);
-    const char *ueventdConfigs[] = {"/etc/ueventd.config", "/vendor/etc/ueventd.config", NULL};
+    const char *ueventdConfigs[] = {"/etc/ueventd.config", "/vendor/etc/ueventd.config",
+        "/vendor/etc/ueventd_factory.config", NULL};
     int i = 0;
     while (ueventdConfigs[i] != NULL) {
         ParseUeventdConfigFile(ueventdConfigs[i++]);