diff --git a/interfaces/innerkits/control_fd/control_fd_client.c b/interfaces/innerkits/control_fd/control_fd_client.c
index dd182277afecb2f306b098a2398b2032b9facde7..f4d7b344a8fe76c06b2a407e858ffb596c3e76bc 100644
--- a/interfaces/innerkits/control_fd/control_fd_client.c
+++ b/interfaces/innerkits/control_fd/control_fd_client.c
@@ -123,7 +123,6 @@ static int SendCmdMessage(const CmdAgent *agent, uint16_t type, const char *cmd,
         BEGET_LOGE("[control_fd] Invalid parameter");
         return -1;
     }
-    int ret = 0;
     BufferHandle handle = NULL;
     uint32_t bufferSize = sizeof(CmdMessage) + strlen(cmd) + PTY_PATH_SIZE + 1;
     handle = LE_CreateBuffer(LE_GetDefaultLoop(), bufferSize);
@@ -132,7 +131,7 @@ static int SendCmdMessage(const CmdAgent *agent, uint16_t type, const char *cmd,
     CmdMessage *message = (CmdMessage *)buff;
     message->msgSize = bufferSize;
     message->type = type;
-    ret = strcpy_s(message->ptyName, PTY_PATH_SIZE - 1, ptyName);
+    int ret = strcpy_s(message->ptyName, PTY_PATH_SIZE - 1, ptyName);
     BEGET_ERROR_CHECK(ret == 0, LE_FreeBuffer(LE_GetDefaultLoop(), agent->task, handle);
         return -1, "[control_fd] Failed to copy pty name %s", ptyName);
     ret = strcpy_s(message->cmd, bufferSize - sizeof(CmdMessage) - PTY_PATH_SIZE, cmd);
diff --git a/interfaces/innerkits/control_fd/control_fd_service.c b/interfaces/innerkits/control_fd/control_fd_service.c
index f955cd0141e6428a896cac07dc0bed0f8bc8748f..cef255472a5cc2ca418a1a2a6231dd351a49d339 100644
--- a/interfaces/innerkits/control_fd/control_fd_service.c
+++ b/interfaces/innerkits/control_fd/control_fd_service.c
@@ -42,7 +42,7 @@ static void CmdOnRecvMessage(const TaskHandle task, const uint8_t *buffer, uint3
 
     // parse msg to exec
     CmdMessage *msg = (CmdMessage *)buffer;
-    if ((msg->type < 0) || (msg->type >= ACTION_MAX) || (msg->cmd[0] == '\0') || (msg->ptyName[0] == '\0')) {
+    if ((msg->type >= ACTION_MAX) || (msg->cmd[0] == '\0') || (msg->ptyName[0] == '\0')) {
         BEGET_LOGE("[control_fd] Received msg is invaild");
         return;
     }
@@ -61,7 +61,9 @@ static void CmdOnRecvMessage(const TaskHandle task, const uint8_t *buffer, uint3
         (void)dup2(fd, STDOUT_FILENO);
         (void)dup2(fd, STDERR_FILENO); // Redirect fd to 0, 1, 2
         (void)close(fd);
-        g_controlFdFunc(msg->type, msg->cmd, NULL);
+        if (g_controlFdFunc != NULL) {
+            g_controlFdFunc(msg->type, msg->cmd, NULL);
+        }
         exit(0);
     } else if (agent->pid < 0) {
         BEGET_LOGE("[control_fd] Failed fork service");
diff --git a/interfaces/innerkits/fs_manager/fstab.c b/interfaces/innerkits/fs_manager/fstab.c
index a5b171df03fa4f801df921c4cc33b2cd4d53ced1..60e9871d27e4191c6ea7d799787a9a958e074c50 100644
--- a/interfaces/innerkits/fs_manager/fstab.c
+++ b/interfaces/innerkits/fs_manager/fstab.c
@@ -432,7 +432,7 @@ int LoadFscryptPolicy(char *buf, size_t size)
         BEGET_LOGE("LoadFscryptPolicy:buf or fscrypt policy is empty");
         return -ENOMEM;
     }
-    if (size <= 0) {
+    if (size == 0) {
         BEGET_LOGE("LoadFscryptPloicy:size is invalid");
         return -EINVAL;
     }
@@ -532,9 +532,8 @@ static int ParseRequiredMountInfo(const char *item, Fstab *fstab)
     BEGET_CHECK(!(item == NULL || *item == '\0' || fstab == NULL), return -1);
 
     char *p = NULL;
-    const char *q = item;
     if ((p = strstr(item, "=")) != NULL) {
-        q = item + strlen(OHOS_REQUIRED_MOUNT_PREFIX); // Get partition name
+        const char *q = item + strlen(OHOS_REQUIRED_MOUNT_PREFIX); // Get partition name
         BEGET_CHECK(!(q == NULL || *q == '\0' || (p - q) <= 0), return -1);
         BEGET_ERROR_CHECK(strncpy_s(partName, NAME_SIZE -1, q, p - q) == EOK,
             return -1, "Failed to copy required partition name");
diff --git a/interfaces/innerkits/fs_manager/fstab_mount.c b/interfaces/innerkits/fs_manager/fstab_mount.c
index 2f7368b81bdcfee4ef89d63c371645a3e797718b..2ca8e25282b1d5e525f760b8b18ddd4cf6368108 100644
--- a/interfaces/innerkits/fs_manager/fstab_mount.c
+++ b/interfaces/innerkits/fs_manager/fstab_mount.c
@@ -42,11 +42,10 @@ const off_t MISC_PARTITION_ACTIVE_SLOT_SIZE = 4;
 
 bool IsSupportedFilesystem(const char *fsType)
 {
-    static const char *supportedFilesystem[] = {"ext4", "f2fs", NULL};
-
     bool supported = false;
-    int index = 0;
     if (fsType != NULL) {
+        static const char *supportedFilesystem[] = {"ext4", "f2fs", NULL};
+        int index = 0;
         while (supportedFilesystem[index] != NULL) {
             if (strcmp(supportedFilesystem[index++], fsType) == 0) {
                 supported = true;
@@ -90,8 +89,8 @@ int DoFormat(const char *devPath, const char *fsType)
         return -1;
     }
     int ret = 0;
-    char blockSizeBuffer[BLOCK_SIZE_BUFFER] = {0};
     if (strcmp(fsType, "ext4") == 0) {
+        char blockSizeBuffer[BLOCK_SIZE_BUFFER] = {0};
         const unsigned int blockSize = 4096;
         if (snprintf_s(blockSizeBuffer, BLOCK_SIZE_BUFFER, BLOCK_SIZE_BUFFER - 1, "%u", blockSize) == -1) {
             BEGET_LOGE("Failed to build block size buffer");
@@ -171,7 +170,7 @@ static int DoResizeF2fs(const char* device, const unsigned long long size)
     }
 
     int ret = 0;
-    if (size <= 0) {
+    if (size == 0) {
         char *cmd[] = {
             file, (char *)device, NULL
         };
@@ -223,7 +222,7 @@ static int DoResizeExt(const char* device, const unsigned long long size)
     }
 
     int ret = 0;
-    if (size <= 0) {
+    if (size == 0) {
         char *cmd[] = {
             file, "-f", (char *)device, NULL
         };
diff --git a/interfaces/innerkits/include/syspara/param_wrapper.h b/interfaces/innerkits/include/syspara/param_wrapper.h
index f0cbedba3e512b55faaec973f471821d02487151..c9b197f00d0b65a8c5c9720c4e2bddafdd5e0c14 100755
--- a/interfaces/innerkits/include/syspara/param_wrapper.h
+++ b/interfaces/innerkits/include/syspara/param_wrapper.h
@@ -20,8 +20,8 @@
 
 namespace OHOS {
 namespace system {
-int GetStringParameter(const std::string key, std::string &value, const std::string def = "");
-int GetIntParameter(const std::string key, int def);
+int GetStringParameter(const std::string &key, std::string &value, const std::string def = "");
+int GetIntParameter(const std::string &key, int def);
 }
 }
 
diff --git a/interfaces/innerkits/reboot/init_reboot_innerkits.c b/interfaces/innerkits/reboot/init_reboot_innerkits.c
index e686b41d5e72e6d7db39d71cb098972c0edf35c4..bf2b0124d81a40c06920fa10ddc5b2bf6ce7ebcb 100644
--- a/interfaces/innerkits/reboot/init_reboot_innerkits.c
+++ b/interfaces/innerkits/reboot/init_reboot_innerkits.c
@@ -47,16 +47,8 @@ static int DoReboot_(const char *option)
     ret = snprintf_s(value, MAX_REBOOT_OPTION_SIZE, MAX_REBOOT_OPTION_SIZE - 1, "reboot,%s", option);
     BEGET_ERROR_CHECK(ret >= 0, return -1, "Failed to copy boot option \" %s \"", option);
 
-    if (strcmp(option, DEVICE_CMD_SUSPEND) == 0) {
-        ret = SystemSetParameter(STARTUP_DEVICE_CTL, DEVICE_CMD_STOP);
-        BEGET_ERROR_CHECK(ret == 0, return -1, "Failed to set stop param");
-    } else if (strcmp(option, DEVICE_CMD_FREEZE) == 0) {
-        ret = SystemSetParameter(STARTUP_DEVICE_CTL, DEVICE_CMD_STOP);
-        BEGET_ERROR_CHECK(ret == 0, return -1, "Failed to set stop param");
-    } else {
-        ret = SystemSetParameter(STARTUP_DEVICE_CTL, DEVICE_CMD_STOP);
-        BEGET_ERROR_CHECK(ret == 0, return -1, "Failed to set stop param");
-    }
+    ret = SystemSetParameter(STARTUP_DEVICE_CTL, DEVICE_CMD_STOP);
+    BEGET_ERROR_CHECK(ret == 0, return -1, "Failed to set stop param");
     ret = SystemSetParameter(DOREBOOT_PARAM, value);
     BEGET_ERROR_CHECK(ret == 0, return -1, "Set parameter to trigger reboot command \" %s \" failed", value);
     return 0;
diff --git a/interfaces/innerkits/syspara/param_wrapper.cpp b/interfaces/innerkits/syspara/param_wrapper.cpp
index 810f6127d0d93c290162ff767d9ce436ae83b077..4fd08de2dc68e369c9e74ef297bd754a33f64579 100644
--- a/interfaces/innerkits/syspara/param_wrapper.cpp
+++ b/interfaces/innerkits/syspara/param_wrapper.cpp
@@ -99,7 +99,7 @@ bool GetBoolParameter(const std::string& key, bool def)
     return def;
 }
 
-int GetStringParameter(const std::string key, std::string &value, const std::string def)
+int GetStringParameter(const std::string &key, std::string &value, const std::string def)
 {
     uint32_t size = 0;
     int ret = SystemReadParam(key.c_str(), NULL, &size);
@@ -173,7 +173,7 @@ std::string GetDeviceType(void)
     return std::string(type);
 }
 
-int GetIntParameter(const std::string key, int def)
+int GetIntParameter(const std::string &key, int def)
 {
     return GetIntParameter(key, def, INT_MIN, INT_MAX);
 }
diff --git a/services/begetctl/misc_daemon.cpp b/services/begetctl/misc_daemon.cpp
index 7cf42fb50e51c6be3c625f185352492ad9287368..25b42fd2768bbcf4d72c0991a9a2896fc5b5161f 100644
--- a/services/begetctl/misc_daemon.cpp
+++ b/services/begetctl/misc_daemon.cpp
@@ -64,7 +64,7 @@ static void ClearLogo(int fd)
 
 static void WriteLogoContent(int fd, const std::string &logoPath, uint32_t size)
 {
-    if (fd < 0 || logoPath.empty() || size <= 0) {
+    if (fd < 0 || logoPath.empty() || size == 0) {
         std::cout << "path is null or size illegal\n";
         return;
     }
diff --git a/services/begetctl/sandbox.cpp b/services/begetctl/sandbox.cpp
index 1ada8e38cd3909fda81d4f404dac16b30fe6612f..502c2e3bc645a47a2a4bb58e1892cf6a94b69c33 100644
--- a/services/begetctl/sandbox.cpp
+++ b/services/begetctl/sandbox.cpp
@@ -94,14 +94,14 @@ static void EnterExec(const std::string &processName)
     const std::string sep = " ";
     OHOS::SplitStr(tmpName, sep, vtr, true, false);
 
-    if ((vtr.size() > MAX_PROCESS_ARGC) || (vtr.size() <= 0)) {
+    if ((vtr.size() > MAX_PROCESS_ARGC) || (vtr.size() == 0)) {
         std::cout << "Service parameters is error." << std::endl;
         return;
     }
     char *argv[MAX_PROCESS_ARGC] = {};
     std::vector<std::string>::iterator it;
     int i = 0;
-    for (it = vtr.begin(); it != vtr.end(); it++) {
+    for (it = vtr.begin(); it != vtr.end(); ++it) {
         argv[i] = (char *)(*it).c_str();
         std::cout << std::string(argv[i]) << std::endl;
         i++;
diff --git a/services/begetctl/shell/shell_bas.c b/services/begetctl/shell/shell_bas.c
index 6d781880b25f5ed742a2d6ba332c5b908ed8c7ae..aa95785ef38d9d0a3f0f10701be2322be052eb43 100644
--- a/services/begetctl/shell/shell_bas.c
+++ b/services/begetctl/shell/shell_bas.c
@@ -561,7 +561,7 @@ static const char *GetRealCmdName(const char *name)
         }
         i++;
     }
-    if ((last != 0) && (name + last != NULL)) {
+    if (last != 0) {
         return name + last + 1;
     } else {
         return name;
diff --git a/services/init/init_capability.c b/services/init/init_capability.c
index 1d40f21b694d2b1e4c0f4114551f2730e242d162..6089e846aaf5a247735ff334c53cc63101f92a1f 100644
--- a/services/init/init_capability.c
+++ b/services/init/init_capability.c
@@ -111,7 +111,7 @@ int GetServiceCaps(const cJSON *curArrItem, Service *service)
             caps = (unsigned int)cJSON_GetNumberValue(capJson);
         } else if (cJSON_IsString(capJson)) {
             capStr = cJSON_GetStringValue(capJson);
-            if (capStr == NULL || strlen(capStr) <= 0) { // check all errors
+            if (capStr == NULL || strlen(capStr) == 0) { // check all errors
                 INIT_LOGE("service=%s, parse item[%d] as string, error.", service->name, i);
                 break;
             }
diff --git a/services/init/lite/init_cmds.c b/services/init/lite/init_cmds.c
index 5cee844bfae6e58c4c16432bcab539908f0d5acb..b81e78c01faf840921d2de231d0020959d7dc71c 100644
--- a/services/init/lite/init_cmds.c
+++ b/services/init/lite/init_cmds.c
@@ -74,7 +74,6 @@ static void DoLoadCfg(const struct CmdArgs *ctx)
 {
     char buf[LOADCFG_BUF_SIZE] = { 0 };
     size_t maxLoop = 0;
-    int len;
     if (!CheckValidCfg(ctx->argv[0])) {
         INIT_LOGE("CheckCfg file %s Failed", ctx->argv[0]);
         return;
@@ -90,7 +89,7 @@ static void DoLoadCfg(const struct CmdArgs *ctx)
 
     while (fgets(buf, LOADCFG_BUF_SIZE - 1, fp) != NULL && maxLoop < LOADCFG_MAX_LOOP) {
         maxLoop++;
-        len = strlen(buf);
+        int len = strlen(buf);
         if (len < 1) {
             continue;
         }
diff --git a/services/init/standard/fd_holder_service.c b/services/init/standard/fd_holder_service.c
index 87a77af9a686bf98bf6f0a3185da4c72634799ed..661a1017f7d7e66230d9fe5f8997843de0a14510 100644
--- a/services/init/standard/fd_holder_service.c
+++ b/services/init/standard/fd_holder_service.c
@@ -135,23 +135,20 @@ static void SendFdsInfo(int sock, Service *service)
 
 static void HandlerGetFds(int sock, Service *service)
 {
-    const char *errorInfo = NULL;
     if (sock < 0 || service == NULL) {
         INIT_LOGE("Get fd from init with invalid parameter");
-        errorInfo = "Invalid parameter";
+        SendErrorInfo(sock, "Invalid parameter", "");
+        return;
     }
 
     if (service->fds == NULL || service->fdCount == 0) {
         INIT_LOGE("Service \' %s \' does not have any held fds", service->name);
-        errorInfo = "Service without any fds";
+        SendErrorInfo(sock, "Service without any fds", service->name);
+        return;
     }
 
-    if (errorInfo != NULL) {
-        SendErrorInfo(sock, errorInfo, service->name);
-    } else {
-        // Send fds back to service
-        SendFdsInfo(sock, service);
-    }
+    // Send fds back to service
+    SendFdsInfo(sock, service);
 }
 
 static int CheckFdHolderPermission(Service *service, pid_t requestPid)
diff --git a/services/init/standard/init_cmds.c b/services/init/standard/init_cmds.c
index fff03b8e99a808d0e9958dfbea1c1d509eae3d7c..5ff0cd55cc5727296b5f1db7fa8bf27fd6d49f8f 100755
--- a/services/init/standard/init_cmds.c
+++ b/services/init/standard/init_cmds.c
@@ -196,8 +196,7 @@ static void DoLoadDefaultParams(const struct CmdArgs *ctx)
 static void DoSyncExec(const struct CmdArgs *ctx)
 {
     // format: syncexec /xxx/xxx/xxx xxx
-    INIT_ERROR_CHECK(ctx != NULL && ctx->argv[0] != NULL, return,
-        "DoSyncExec: invalid arguments to exec \"%s\"", ctx->argv[0]);
+    INIT_ERROR_CHECK(ctx != NULL && ctx->argv[0] != NULL, return, "DoSyncExec: invalid arguments");
     SyncExecCommand(ctx->argc, ctx->argv);
     return;
 }
@@ -205,8 +204,7 @@ static void DoSyncExec(const struct CmdArgs *ctx)
 static void DoExec(const struct CmdArgs *ctx)
 {
     // format: exec /xxx/xxx/xxx xxx
-    INIT_ERROR_CHECK(ctx != NULL && ctx->argv[0] != NULL, return,
-        "DoExec: invalid arguments to exec \"%s\"", ctx->argv[0]);
+    INIT_ERROR_CHECK(ctx != NULL && ctx->argv[0] != NULL, return, "DoExec: invalid arguments");
     pid_t pid = fork();
     INIT_ERROR_CHECK(pid >= 0, return, "DoExec: failed to fork child process to exec \"%s\"", ctx->argv[0]);
 
diff --git a/services/modules/bootchart/bootchart.c b/services/modules/bootchart/bootchart.c
index 2e445180d884b1f69a2e4af95bc2b91f8cf21db7..e241b7e0815d771a429c3bc067a3cdc08837eff0 100644
--- a/services/modules/bootchart/bootchart.c
+++ b/services/modules/bootchart/bootchart.c
@@ -71,7 +71,7 @@ static void BootchartLogHeader(void)
     struct tm *now = localtime(&tm);
     PLUGIN_CHECK(now != NULL, return, "Failed to get local time");
     size_t size = strftime(date, sizeof(date), "%F %T", now);
-    PLUGIN_CHECK(size >= 0, return, "Failed to strftime");
+    PLUGIN_CHECK(size > 0, return, "Failed to strftime");
     struct utsname uts;
     if (uname(&uts) == -1) {
         return;
@@ -224,12 +224,11 @@ static int DoBootchartStart(void)
         PLUGIN_LOGI("bootcharting has been start");
         return 0;
     }
-    int ret = 0;
     g_bootchartCtrl = malloc(sizeof(BootchartCtrl));
     PLUGIN_CHECK(g_bootchartCtrl != NULL, return -1, "Failed to alloc mem for bootchart");
     g_bootchartCtrl->bufferSize = DEFAULT_BUFFER;
 
-    ret = pthread_mutex_init(&(g_bootchartCtrl->mutex), NULL);
+    int ret = pthread_mutex_init(&(g_bootchartCtrl->mutex), NULL);
     PLUGIN_CHECK(ret == 0, BootchartDestory();
         return -1, "Failed to init mutex");
     ret = pthread_cond_init(&(g_bootchartCtrl->cond), NULL);
diff --git a/services/param/base/param_comm.c b/services/param/base/param_comm.c
index 049013e1c38efa48a71a26381b413a86af935375..3afe0e3c309fe53c012e94279a11540d969eb903 100644
--- a/services/param/base/param_comm.c
+++ b/services/param/base/param_comm.c
@@ -371,6 +371,7 @@ INIT_LOCAL_API int AddSecurityLabel(const ParamAuditData *auditData)
     } else {
 #ifdef STARTUP_INIT_TEST
         ParamSecurityNode *label = (ParamSecurityNode *)GetTrieNode(workSpace, node->labelIndex);
+        PARAM_CHECK(label != NULL, return -1, "Failed to get trie node");
         label->mode = auditData->dacData.mode;
         label->uid = auditData->dacData.uid;
         label->gid = auditData->dacData.gid;
diff --git a/services/param/linux/param_message.c b/services/param/linux/param_message.c
index 9926e39ba9e85d58ddb153e51a2541f7a3cb1e25..aef43170b299200ef0bb88f638e3e1d835d998ea 100644
--- a/services/param/linux/param_message.c
+++ b/services/param/linux/param_message.c
@@ -23,9 +23,10 @@
 int ConnectServer(int fd, const char *servername)
 {
     PARAM_CHECK(fd >= 0, return -1, "Invalid fd %d", fd);
+    PARAM_CHECK(servername != NULL, return -1, "Invalid servername");
     int opt = 1;
     int ret = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &opt, sizeof(opt));
-    PARAM_CHECK(servername != NULL, return -1, "Invalid servername");
+    PARAM_CHECK(ret == 0, return -1, "Failed to set socket option");
     struct sockaddr_un addr;
     /* fill socket address structure with server's address */
     ret = memset_s(&addr, sizeof(addr), 0, sizeof(addr));
diff --git a/services/param/linux/param_message.h b/services/param/linux/param_message.h
index bdaceef363500c3d7e0c3e59ab085154f0720ed9..287bffaafa9c9c6b2b7003c6bc1f6a81b6a86a20 100755
--- a/services/param/linux/param_message.h
+++ b/services/param/linux/param_message.h
@@ -84,8 +84,9 @@ int ParamServiceStop(void);
 int ParamServiceStart(void);
 
 int ParamTaskClose(const ParamTaskPtr stream);
-int ParamServerCreate(ParamTaskPtr *server, const ParamStreamInfo *info);
-int ParamStreamCreate(ParamTaskPtr *client, ParamTaskPtr server, const ParamStreamInfo *info, uint16_t userDataSize);
+int ParamServerCreate(ParamTaskPtr *stream, const ParamStreamInfo *streamInfo);
+int ParamStreamCreate(ParamTaskPtr *stream, ParamTaskPtr server,
+                      const ParamStreamInfo *streamInfo, uint16_t userDataSize);
 int ParamTaskSendMsg(const ParamTaskPtr stream, const ParamMessage *msg);
 
 int ParamEventTaskCreate(ParamTaskPtr *stream, LE_ProcessAsyncEvent eventProcess);
diff --git a/services/param/linux/param_request.c b/services/param/linux/param_request.c
index 01af739af05c7992d00cfdc81cb1d12e18abe544..19a6f69df48753c03e06bd06e88cc56d9ece664e 100644
--- a/services/param/linux/param_request.c
+++ b/services/param/linux/param_request.c
@@ -132,14 +132,13 @@ static int GetClientSocket(int timeout)
 
 static int StartRequest(int clientFd, ParamMessage *request, int timeout)
 {
-    int ret = 0;
     ssize_t sendLen = send(clientFd, (char *)request, request->msgSize, 0);
     if (errno == EINVAL || errno == EACCES) {
         return PARAM_CODE_INVALID_SOCKET;
     }
     PARAM_CHECK(sendLen >= 0, return PARAM_CODE_FAIL_CONNECT, "Failed to send message err: %d", errno);
     PARAM_LOGV("sendMessage sendLen fd %d %zd", clientFd, sendLen);
-    ret = ReadMessage(clientFd, (char *)request, timeout);
+    int ret = ReadMessage(clientFd, (char *)request, timeout);
     if (ret == 0) {
         ret = ProcessRecvMsg(request);
     }
diff --git a/services/param/liteos/param_litedac.c b/services/param/liteos/param_litedac.c
index 327f05aa16823a5ca4e2377b59a57cb9115bca59..575a86a6c7d41ade16d5ddc53a6f564ef47c2a90 100644
--- a/services/param/liteos/param_litedac.c
+++ b/services/param/liteos/param_litedac.c
@@ -59,9 +59,6 @@ static int DacCheckParamPermission(const ParamSecurityLabel *srcLabel, const cha
 #if defined(__LITEOS_A__)
     uid_t uid = getuid();
     return uid <= SYS_UID_INDEX ? DAC_RESULT_PERMISSION : DAC_RESULT_FORBIDED;
-#endif
-#if defined(__LITEOS_M__)
-    return DAC_RESULT_PERMISSION;
 #endif
     return DAC_RESULT_PERMISSION;
 }
diff --git a/services/param/manager/param_manager.c b/services/param/manager/param_manager.c
index 1570226075e1245bd8a902c9a7214af015784793..1b9d90e3186610d0c53aa9e73067f949572f1101 100644
--- a/services/param/manager/param_manager.c
+++ b/services/param/manager/param_manager.c
@@ -139,7 +139,7 @@ static int DumpTrieDataNodeTraversal(const WorkSpace *workSpace, const ParamTrie
         ParamNode *entry = (ParamNode *)GetTrieNode(workSpace, current->dataIndex);
         if (entry != NULL) {
             PARAM_DUMP("\tparameter length info [%u, %u] \n\t  param: %s \n",
-                entry->keyLength, entry->valueLength, (entry != NULL) ? entry->data : "null");
+                entry->keyLength, entry->valueLength, entry->data);
         }
     }
     if (current->labelIndex != 0 && verbose) {
diff --git a/services/param/manager/param_persist.c b/services/param/manager/param_persist.c
index 2d6397bcda998afda4eef1c1e664cd7e23783566..60b8af3467c6efd550b25140c10e818aecdcc9c2 100644
--- a/services/param/manager/param_persist.c
+++ b/services/param/manager/param_persist.c
@@ -226,7 +226,7 @@ int LoadPersistParams(void)
     }
 #endif
     if (g_persistWorkSpace.persistParamOps.load != NULL) {
-        ret = g_persistWorkSpace.persistParamOps.load();
+        (void)g_persistWorkSpace.persistParamOps.load();
         PARAM_SET_FLAG(g_persistWorkSpace.flags, WORKSPACE_FLAGS_LOADED);
     }
     // save new persist param
diff --git a/services/param/manager/param_server.c b/services/param/manager/param_server.c
index ef585b2f73f9af00a7abb8056149cd78e62e9715..d1e83952f0a440fdb35bcafba4b73844d96d9ea0 100755
--- a/services/param/manager/param_server.c
+++ b/services/param/manager/param_server.c
@@ -78,7 +78,7 @@ static int ReadSnFromFile(const char *name, const char *file)
     PARAM_LOGV("**** name %s, value %s", name, data);
     int ret = WriteParam(name, data, NULL, 0);
     free(data);
-    PARAM_CHECK(ret == 0, return ret, "Failed to write param %s %s", name, data);
+    PARAM_CHECK(ret == 0, return ret, "Failed to write param %s", name);
     return ret;
 }
 
@@ -113,7 +113,6 @@ static int SnDealFun(const char *name, const char *value, int res)
 
 INIT_LOCAL_API int LoadParamFromCmdLine(void)
 {
-    int ret;
     static const cmdLineInfo cmdLines[] = {
         {OHOS_BOOT"hardware", CommonDealFun
         },
@@ -133,6 +132,7 @@ INIT_LOCAL_API int LoadParamFromCmdLine(void)
         return -1, "Failed to read file %s", BOOT_CMD_LINE);
 
     for (size_t i = 0; i < ARRAY_LENGTH(cmdLines); i++) {
+        int ret = 0;
 #ifdef BOOT_EXTENDED_CMDLINE
         ret = GetParamValueFromBuffer(cmdLines[i].name, BOOT_EXTENDED_CMDLINE, value, PARAM_CONST_VALUE_LEN_MAX);
         if (ret != 0) {
diff --git a/services/param/trigger/trigger_checker.c b/services/param/trigger/trigger_checker.c
index 268efb49baf6c7741cac2810731d1e285a75da75..6d61552e056b5e32981c52c9d68a4eaf03dd1d08 100644
--- a/services/param/trigger/trigger_checker.c
+++ b/services/param/trigger/trigger_checker.c
@@ -187,7 +187,7 @@ static int ComputeSubCondition(const LogicCalculator *calculator, LogicData *dat
     // check name
     if ((calculator->inputName != NULL) && (strcmp(calculator->conditionName, calculator->inputName) == 0)) {
         return CompareValue(calculator->conditionContent, calculator->inputContent);
-    } else if (calculator->conditionName != NULL && strlen(calculator->conditionName) > 0) {
+    } else if (strlen(calculator->conditionName) > 0) {
         uint32_t len = SUPPORT_DATA_BUFFER_MAX;
         ret = SystemReadParam(calculator->conditionName, calculator->readContent, &len);
         if (ret != 0) {
diff --git a/services/param/watcher/agent/watcher_manager_kits.h b/services/param/watcher/agent/watcher_manager_kits.h
index 9410c73b8d805e6b893a54b4c3c92e8d5aebc4d5..456a3bd8f052ce48814adffc67c07f9321470ba8 100644
--- a/services/param/watcher/agent/watcher_manager_kits.h
+++ b/services/param/watcher/agent/watcher_manager_kits.h
@@ -46,7 +46,7 @@ private:
             : callback_(callback), context_(context) {}
         ~ParameterChangeListener() = default;
 
-        bool IsEqual(ParameterChangePtr callback, void *context)
+        bool IsEqual(ParameterChangePtr callback, void *context) const
         {
             return (callback == callback_ && context == context_);
         }
diff --git a/services/param/watcher/proxy/watcher_manager.cpp b/services/param/watcher/proxy/watcher_manager.cpp
index 88e89c5634e46c875edff4db3f459d60608d4f35..57df856616a8e0a4066a3bbd023bed363dcb324b 100644
--- a/services/param/watcher/proxy/watcher_manager.cpp
+++ b/services/param/watcher/proxy/watcher_manager.cpp
@@ -202,8 +202,10 @@ void WatcherManager::WatcherGroup::ProcessParameterChange(const std::string &nam
     // walk watcher
     ListNode *node = nullptr;
     ForEachListEntry(&watchers_, node) {
-        ParamWatcher *watcher = (ParamWatcher *)node;
-        watcher->ProcessParameterChange(name, value);
+        if (node != nullptr) {
+            ParamWatcher *watcher = (ParamWatcher *)node;
+            watcher->ProcessParameterChange(name, value);
+        }
     }
 }
 
@@ -290,14 +292,12 @@ int WatcherManager::GetServerFd(bool retry)
     if (serverFd_ != INVALID_SOCKET) {
         return serverFd_;
     }
-    int ret = 0;
     int32_t retryCount = 0;
     do {
         serverFd_ = socket(PF_UNIX, SOCK_STREAM, 0);
         int flags = fcntl(serverFd_, F_GETFL, 0);
         (void)fcntl(serverFd_, F_SETFL, flags & ~O_NONBLOCK);
-        ret = ConnectServer(serverFd_, CLIENT_PIPE_NAME);
-        if (ret == 0) {
+        if (ConnectServer(serverFd_, CLIENT_PIPE_NAME) == 0) {
             break;
         }
         close(serverFd_);
diff --git a/services/param/watcher/proxy/watcher_manager.h b/services/param/watcher/proxy/watcher_manager.h
index c971d3215f16986f135868e1fbe4ba55347d8979..0d0db3f8aa1f656fa548f2b526da7cc759f8e82a 100644
--- a/services/param/watcher/proxy/watcher_manager.h
+++ b/services/param/watcher/proxy/watcher_manager.h
@@ -71,7 +71,7 @@ public:
         }
         ~ParamWatcher() = default;
 
-        uint32_t GetWatcherId()
+        uint32_t GetWatcherId() const
         {
             return watcherId_;
         }
@@ -83,7 +83,7 @@ public:
         {
             return &groupNode_;
         }
-        sptr<IWatcher> GetRemoteWatcher()
+        sptr<IWatcher> GetRemoteWatcher() const
         {
             return watcher_;
         }
diff --git a/services/utils/list.c b/services/utils/list.c
index bd354a3d7c2e156ca8748b3e6648f1672e3874f9..1214eb267557804392d1a850225d63a403035477 100644
--- a/services/utils/list.c
+++ b/services/utils/list.c
@@ -83,7 +83,6 @@ void OH_ListRemove(struct ListNode *item)
 void OH_ListAddWithOrder(struct ListNode *head, struct ListNode *item, ListCompareProc compareProc)
 {
     ListNode *match;
-    int ret;
 
     if (head == NULL || item == NULL || compareProc == NULL) {
         return;
@@ -91,8 +90,7 @@ void OH_ListAddWithOrder(struct ListNode *head, struct ListNode *item, ListCompa
 
     match = head->next;
     while ((match != NULL) && (match != head)) {
-        ret = compareProc(match, item);
-        if (ret > 0) {
+        if (compareProc(match, item) > 0) {
             break;
         }
         match = match->next;
@@ -153,7 +151,6 @@ ListNode *OH_ListFind(const ListNode *head, void *data, ListTraversalProc compar
  */
 int OH_ListTraversal(ListNode *head, void *data, ListTraversalProc traversalProc, unsigned int flags)
 {
-    int ret;
     ListNode *match;
     ListNode *next;
 
@@ -172,7 +169,7 @@ int OH_ListTraversal(ListNode *head, void *data, ListTraversalProc traversalProc
         } else {
             next = match->next;
         }
-        ret = traversalProc(match, data);
+        int ret = traversalProc(match, data);
         if ((ret != 0) && IS_STOP_WHEN_ERROR(flags)) {
             return ret;
         }
diff --git a/test/unittest/init/group_unittest.cpp b/test/unittest/init/group_unittest.cpp
index 96d7a868c06630dee70e52a104b7bd83f0285d00..701808ded43e3dce47d14c50f924ecca7c5c37ce 100644
--- a/test/unittest/init/group_unittest.cpp
+++ b/test/unittest/init/group_unittest.cpp
@@ -50,7 +50,8 @@ static int TestHashNodeFunction(const HashNode *node)
 {
     TestHashNode *testNode = HASHMAP_ENTRY(node, TestHashNode, node);
     int code = 0;
-    for (size_t i = 0; i < strlen(testNode->name); i++) {
+    size_t nameLen = strlen(testNode->name);
+    for (size_t i = 0; i < nameLen; i++) {
         code += testNode->name[i] - 'A';
     }
     return code;
@@ -60,7 +61,8 @@ static int TestHashKeyFunction(const void *key)
 {
     int code = 0;
     char *buff = const_cast<char *>(static_cast<const char *>(key));
-    for (size_t i = 0; i < strlen(buff); i++) {
+    size_t buffLen = strlen(buff);
+    for (size_t i = 0; i < buffLen; i++) {
         code += buff[i] - 'A';
     }
     return code;
diff --git a/ueventd/standard/ueventd_parameter.c b/ueventd/standard/ueventd_parameter.c
index d803153af2b119ac6637a1db4d80bdc8ff93dee9..e8b3e290a40aa6ff91fe3b0bfe8d840f728f2222 100644
--- a/ueventd/standard/ueventd_parameter.c
+++ b/ueventd/standard/ueventd_parameter.c
@@ -67,7 +67,7 @@ static void *ThreadRun(void *data)
     char paramName[PARAM_NAME_LEN_MAX] = {0};
     while (1) {
         pthread_mutex_lock(&(parameterCtrl->lock));
-        while (parameterCtrl->empty) {
+        if (parameterCtrl->empty) {
             struct timespec abstime = {};
             struct timeval now = {};
             const long timeout = 5000; // wait time 5000ms
@@ -76,7 +76,6 @@ static void *ThreadRun(void *data)
             abstime.tv_sec = now.tv_sec + nsec / 1000000000 + timeout / 1000; // 1000 unit 1000000000 unit nsec
             abstime.tv_nsec = nsec % 1000000000; // 1000000000 unit nsec
             pthread_cond_timedwait(&(parameterCtrl->hasData), &(parameterCtrl->lock), &abstime);
-            break;
         }
         if (parameterCtrl->shutdown) {
             break;