fix log

Signed-off-by: Ncheng_jinsong <chengjinsong2@huawei.com>

interfaces/innerkits/fs_manager/fstab.c

@@ -328,7 +328,7 @@ int GetBlockDeviceByMountPoint(const char *mountPoint, const Fstab *fstab, char
     }
     FstabItem *item = FindFstabItemForMountPoint(*fstab, mountPoint);
     if (item == NULL) {
-        BEGET_LOGE("Failed to get fstab item from point \" %s \"", mountPoint);
+        BEGET_LOGE("Failed to get fstab item from mount point \" %s \"", mountPoint);
         return -1;
     }
     if (strncpy_s(deviceName, nameLen, item->deviceName, strlen(item->deviceName)) != 0) {
@@ -398,7 +398,6 @@ static unsigned long ParseDefaultMountFlag(const char *str)
 
 static bool IsFscryptOption(const char *option)
 {
-    BEGET_LOGI("IsFscryptOption start");
     if (!option) {
         return false;
     }
@@ -510,7 +509,7 @@ int GetBlockDevicePath(const char *partName, char *path, size_t size)
     BEGET_CHECK_RETURN_VALUE(fstab != NULL, -1);
     int ret = GetBlockDeviceByMountPoint(partName, fstab, path, size);
     BEGET_INFO_CHECK(ret == 0, ret = GetBlockDeviceByName(partName, fstab, path, size),
-        "mount point not found, try to get it by device name");
+        "Mount point not found, try to get path by device name.");
     ReleaseFstab(fstab);
     return ret;
 }

interfaces/innerkits/sandbox/sandbox.c

@@ -138,15 +138,15 @@ static int AddMountInfoToSandbox(sandbox_t *sandbox, cJSON *item, const char *ty
 {
     BEGET_CHECK(!(sandbox == NULL || item == NULL || type == NULL), return -1);
     char *srcPath = cJSON_GetStringValue(cJSON_GetObjectItem(item, SANDBOX_SOURCE));
-    BEGET_ERROR_CHECK(srcPath != NULL, return 0, "Get src-path is null");
+    BEGET_INFO_CHECK(srcPath != NULL, return 0, "Get src-path is null");
     char *dstPath = cJSON_GetStringValue(cJSON_GetObjectItem(item, SANDBOX_TARGET));
-    BEGET_ERROR_CHECK(dstPath != NULL, return 0, "Get sandbox-path is null");
+    BEGET_INFO_CHECK(dstPath != NULL, return 0, "Get sandbox-path is null");
     cJSON *obj = cJSON_GetObjectItem(item, SANDBOX_FLAGS);
-    BEGET_ERROR_CHECK(obj != NULL, return 0, "Get sandbox-flags is null");
+    BEGET_INFO_CHECK(obj != NULL, return 0, "Get sandbox-flags is null");
     int ret = cJSON_IsArray(obj);
-    BEGET_ERROR_CHECK(ret, return 0, "Sandbox-flags is not array");
+    BEGET_INFO_CHECK(ret, return 0, "Sandbox-flags is not array");
     int count = cJSON_GetArraySize(obj);
-    BEGET_ERROR_CHECK(count > 0, return 0, "Get sandbox-flags array size is zero");
+    BEGET_INFO_CHECK(count > 0, return 0, "Get sandbox-flags array size is zero");
     mountlist_t *tmpMount = (mountlist_t *)calloc(1, sizeof(mountlist_t));
     BEGET_ERROR_CHECK(tmpMount != NULL, return -1, "Failed calloc err=%d", errno);
     tmpMount->info = (mount_t *)calloc(1, sizeof(mount_t));
@@ -214,7 +214,7 @@ static int GetSandboxInfo(sandbox_t *sandbox, cJSON *root, const char *itemName)
     BEGET_ERROR_CHECK(cJSON_IsArray(obj), return 0, "%s with invalid type, should be array", itemName);
 
     int counts = cJSON_GetArraySize(obj);
-    BEGET_ERROR_CHECK(!(counts <= 0), return 0, "Item %s array size is zero.", itemName);
+    BEGET_ERROR_CHECK(counts > 0, return 0, "Item %s array size is zero.", itemName);
     AddInfoToSandboxCallback func = NULL;
     if (strcmp(itemName, SANDBOX_MOUNT_PATH_TAG) == 0) {
         func = AddMountInfoToSandbox;
@@ -339,12 +339,9 @@ static int BindMount(const char *source, const char *target, unsigned long flags
     }
 
     BEGET_WARNING_CHECK((tmpflags & MS_BIND) != 0, tmpflags |= MS_BIND,
-        "Not configure bind, must configure bind flag.");
-
-    if ((tmpflags & MS_REC) == 0) {
-        BEGET_LOGW("Not configure rec, must configure rec flag.");
-        tmpflags |= MS_REC;
-    }
+        "Not configure mount bind, must configure mount bind flag.");
+    BEGET_WARNING_CHECK((tmpflags & MS_REC) != 0, tmpflags |= MS_REC,
+        "Not configure mount rec, must configure mount rec flag.");
 
     // do mount
     if (mount(source, target, NULL, tmpflags, NULL) != 0) {

interfaces/innerkits/socket/init_socket.c

@@ -28,14 +28,12 @@
 static int GetControlFromEnv(const char *path, int length)
 {
     BEGET_CHECK_RETURN_VALUE(path != NULL && length > 0, -1);
-    BEGET_LOGI("GetControlFromEnv path is %s ", path);
     const char *val = getenv(path);
-    BEGET_ERROR_CHECK(val != NULL, return -1, "GetControlFromEnv val is null %d", errno);
+    BEGET_ERROR_CHECK(val != NULL, return -1, "Get environment from %s failed", path);
     errno = 0;
     int fd = strtol(val, NULL, N_DEC);
-    BEGET_CHECK_RETURN_VALUE(errno == 0, -1);
-    BEGET_LOGI("GetControlFromEnv fd is %d ", fd);
-    BEGET_ERROR_CHECK(fcntl(fd, F_GETFD) >= 0, return -1, "GetControlFromEnv errno %d ", errno);
+    BEGET_ERROR_CHECK(errno == 0, return -1, "Failed strtol err=%d", errno);
+    BEGET_ERROR_CHECK(fcntl(fd, F_GETFD) >= 0, return -1, "Failed fcntl err=%d ", errno);
     return fd;
 }
 
@@ -45,26 +43,23 @@ int GetControlSocket(const char *name)
     char path[MAX_SOCKET_ENV_PREFIX_LEN] = {0};
     BEGET_CHECK_RETURN_VALUE(snprintf_s(path, sizeof(path), sizeof(path) - 1, OHOS_SOCKET_ENV_PREFIX"%s",
         name) != -1, -1);
-    BEGET_LOGI("GetControlSocket path is %s ", path);
     int fd = GetControlFromEnv(path, MAX_SOCKET_ENV_PREFIX_LEN);
-    BEGET_ERROR_CHECK(fd >= 0, return -1, "GetControlFromEnv fail ");
+    BEGET_ERROR_CHECK(fd >= 0, return -1, "Get control fd from environment failed");
     int addrFamily = 0;
     socklen_t afLen = sizeof(addrFamily);
     int ret = getsockopt(fd, SOL_SOCKET, SO_DOMAIN, &addrFamily, &afLen);
-    BEGET_ERROR_CHECK(ret == 0, return -1, "get socket option fail, errno %d ", errno);
-    BEGET_LOGI("socket %s fd %d address family %d", name, fd, addrFamily);
+    BEGET_ERROR_CHECK(ret == 0, return -1, "Get socket option fail, err=%d ", errno);
     if (addrFamily != AF_UNIX) {
         return fd;
     }
     struct sockaddr_un addr;
     socklen_t addrlen = sizeof(addr);
     ret = getsockname(fd, (struct sockaddr*)&addr, &addrlen);
-    BEGET_ERROR_CHECK(ret >= 0, return -1, "GetControlSocket errno %d ", errno);
+    BEGET_ERROR_CHECK(ret >= 0, return -1, "Failed getsockname err=%d ", errno);
     char sockDir[MAX_SOCKET_DIR_LEN] = {0};
     BEGET_CHECK_RETURN_VALUE(snprintf_s(sockDir, sizeof(sockDir), sizeof(sockDir) - 1, OHOS_SOCKET_DIR"/%s",
         name) != -1, -1);
-    BEGET_LOGI("sockDir %s ", sockDir);
-    BEGET_LOGI("addr.sun_path %s ", addr.sun_path);
+    BEGET_LOGV("Compary sockDir %s and addr.sun_path %s", sockDir, addr.sun_path);
     if (strncmp(sockDir, addr.sun_path, strlen(sockDir)) == 0) {
         return fd;
     }

services/init/include/init_cmds.h

@@ -17,7 +17,10 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/stat.h>
+#include <sys/time.h>
 #include <sys/types.h>
+#include <time.h>
+
 #include "cJSON.h"
 #ifdef __cplusplus
 #if __cplusplus
@@ -68,6 +71,11 @@ struct CmdTable {
     void (*DoFuncion)(const struct CmdArgs *ctx);
 };
 
+typedef struct INIT_TIMING_STAT {
+    struct timespec startTime;
+    struct timespec endTime;
+} INIT_TIMING_STAT;
+
 int GetParamValue(const char *symValue, unsigned int symLen, char *paramValue, unsigned int paramLen);
 const struct CmdArgs *GetCmdArg(const char *cmdContent, const char *delim, int argsCount);
 void FreeCmdArg(struct CmdArgs *cmd);
@@ -84,6 +92,7 @@ void ExecCmd(const struct CmdTable *cmd, const char *cmdContent);
 int SetFileCryptPolicy(const char *dir);
 
 void OpenHidebug(const char *name);
+long long InitDiffTime(INIT_TIMING_STAT *stat);
 #ifdef __cplusplus
 #if __cplusplus
 }

services/init/init_common_cmds.c

@@ -316,7 +316,7 @@ static void DoMkDir(const struct CmdArgs *ctx)
     }
     mode_t mode = DEFAULT_DIR_MODE;
     if (mkdir(ctx->argv[0], mode) != 0 && errno != EEXIST) {
-        INIT_LOGE("DoMkDir, failed for '%s', err %d.", ctx->argv[0], errno);
+        INIT_LOGE("Create directory '%s' failed, err=%d.", ctx->argv[0], errno);
         return;
     }
 
@@ -338,7 +338,7 @@ static void DoMkDir(const struct CmdArgs *ctx)
     }
     ret = SetFileCryptPolicy(ctx->argv[0]);
     if (ret != 0) {
-        INIT_LOGW("failed to set file fscrypt");
+        INIT_LOGW("Failed to set file fscrypt");
     }
 
     return;
@@ -354,7 +354,7 @@ static void DoChmod(const struct CmdArgs *ctx)
     }
 
     if (chmod(ctx->argv[1], mode) != 0) {
-        INIT_LOGE("Failed to change mode \" %s \" mode to %04o, err = %d", ctx->argv[1], mode, errno);
+        INIT_LOGE("Failed to change mode \" %s \" to %04o, err=%d", ctx->argv[1], mode, errno);
     }
 }
 
@@ -525,21 +525,21 @@ static void DoSetrlimit(const struct CmdArgs *ctx)
         INIT_LOGE("DoSetrlimit failed, resources :%s not support.", ctx->argv[0]);
         return;
     }
-    INIT_CHECK_ONLY_ELOG(setrlimit(rcs, &limit) == 0, "DoSetrlimit failed : %d", errno);
+    INIT_CHECK_ONLY_ELOG(setrlimit(rcs, &limit) == 0, "Failed setrlimit err=%d", errno);
     return;
 }
 
 static void DoRm(const struct CmdArgs *ctx)
 {
     // format: rm /xxx/xxx/xxx
-    INIT_CHECK_ONLY_ELOG(unlink(ctx->argv[0]) != -1, "DoRm: unlink %s failed: %d.", ctx->argv[0], errno);
+    INIT_CHECK_ONLY_ELOG(unlink(ctx->argv[0]) != -1, "Failed unlink %s err=%d.", ctx->argv[0], errno);
     return;
 }
 
 static void DoExport(const struct CmdArgs *ctx)
 {
     // format: export xxx /xxx/xxx/xxx
-    INIT_CHECK_ONLY_ELOG(setenv(ctx->argv[0], ctx->argv[1], 1) == 0, "DoExport: set %s with %s failed: %d",
+    INIT_CHECK_ONLY_ELOG(setenv(ctx->argv[0], ctx->argv[1], 1) == 0, "Failed setenv %s with %s err=%d.",
         ctx->argv[0], ctx->argv[1], errno);
     return;
 }
@@ -693,17 +693,33 @@ int GetCmdLinesFromJson(const cJSON *root, CmdLines **cmdLines)
     return 0;
 }
 
+long long  InitDiffTime(INIT_TIMING_STAT *stat)
+{
+    long long diff = (long long)((stat->endTime.tv_sec - stat->startTime.tv_sec) * 1000000); // 1000000 1000ms
+    if (stat->endTime.tv_nsec > stat->startTime.tv_nsec) {
+        diff += (stat->endTime.tv_nsec - stat->startTime.tv_nsec) / 1000; // 1000 ms
+    } else {
+        diff -= (stat->startTime.tv_nsec - stat->endTime.tv_nsec) / 1000; // 1000 ms
+    }
+    return diff;
+}
+
 void DoCmdByName(const char *name, const char *cmdContent)
 {
     if (name == NULL || cmdContent == NULL) {
         return;
     }
+    INIT_TIMING_STAT cmdTimer;
+    (void)clock_gettime(CLOCK_MONOTONIC, &cmdTimer.startTime);
     const struct CmdTable *cmd = GetCmdByName(name);
     if (cmd != NULL) {
         ExecCmd(cmd, cmdContent);
-        return;
+    } else {
+        PluginExecCmdByName(name, cmdContent);
     }
-    PluginExecCmdByName(name, cmdContent);
+    (void)clock_gettime(CLOCK_MONOTONIC, &cmdTimer.endTime);
+    long long diff = InitDiffTime(&cmdTimer);
+    INIT_LOGV("Command %s execute time %lld", name, diff);
 }
 
 void DoCmdByIndex(int index, const char *cmdContent)
@@ -712,16 +728,23 @@ void DoCmdByIndex(int index, const char *cmdContent)
         return;
     }
     int cmdCnt = 0;
+    INIT_TIMING_STAT cmdTimer;
+    (void)clock_gettime(CLOCK_MONOTONIC, &cmdTimer.startTime);
     const struct CmdTable *commCmds = GetCommCmdTable(&cmdCnt);
     if (index < cmdCnt) {
         ExecCmd(&commCmds[index], cmdContent);
-        return;
-    }
-    int number = 0;
-    const struct CmdTable *cmds = GetCmdTable(&number);
-    if (index < (cmdCnt + number)) {
-        ExecCmd(&cmds[index - cmdCnt], cmdContent);
-        return;
+        INIT_LOGV("Command: %s content: %s", commCmds[index].name, cmdContent);
+    } else {
+        int number = 0;
+        const struct CmdTable *cmds = GetCmdTable(&number);
+        if (index < (cmdCnt + number)) {
+            ExecCmd(&cmds[index - cmdCnt], cmdContent);
+            INIT_LOGV("Command: %s content: %s", cmds[index - cmdCnt].name, cmdContent);
+        } else {
+            PluginExecCmdByCmdIndex(index, cmdContent);
+        }
     }
-    PluginExecCmdByCmdIndex(index, cmdContent);
+    (void)clock_gettime(CLOCK_MONOTONIC, &cmdTimer.endTime);
+    long long diff = InitDiffTime(&cmdTimer);
+    INIT_LOGV("Command execute time %lld", diff);
 }

services/init/init_common_service.c

@@ -295,13 +295,13 @@ static int InitServiceProperties(Service *service)
 {
     INIT_ERROR_CHECK(service != NULL, return -1, "Invalid parameter.");
     SetServiceEnterSandbox(service->pathArgs.argv[0], service->attribute);
-    INIT_CHECK_ONLY_ELOG(SetAccessToken(service) == SERVICE_SUCCESS, "access token failed %s", service->name);
+    INIT_CHECK_ONLY_ELOG(SetAccessToken(service) == SERVICE_SUCCESS,
+        "Set service %s access token failed", service->name);
     // deal start job
     if (service->serviceJobs.jobsName[JOB_ON_START] != NULL) {
         DoJobNow(service->serviceJobs.jobsName[JOB_ON_START]);
     }
     ClearEnvironment(service);
-
     if (!IsOnDemandService(service)) {
         INIT_ERROR_CHECK(CreateServiceSocket(service) >= 0, return -1,
             "service %s exit! create socket failed!", service->name);
@@ -321,7 +321,7 @@ static int InitServiceProperties(Service *service)
     // permissions
     INIT_ERROR_CHECK(SetPerms(service) == SERVICE_SUCCESS, return -1,
         "service %s exit! set perms failed! err %d.", service->name, errno);
-    
+
     // write pid
     INIT_ERROR_CHECK(WritePid(service) == SERVICE_SUCCESS, return -1,
         "service %s exit! write pid failed!", service->name);
@@ -350,7 +350,7 @@ void EnterServiceSandbox(Service *service)
 int ServiceStart(Service *service)
 {
     INIT_ERROR_CHECK(service != NULL, return SERVICE_FAILURE, "start service failed! null ptr.");
-    INIT_ERROR_CHECK(service->pid <= 0, return SERVICE_SUCCESS, "service : %s had started already.", service->name);
+    INIT_ERROR_CHECK(service->pid <= 0, return SERVICE_SUCCESS, "Service %s already started", service->name);
     INIT_ERROR_CHECK(service->pathArgs.count > 0,
         return SERVICE_FAILURE, "start service %s pathArgs is NULL.", service->name);
 
@@ -382,7 +382,7 @@ int ServiceStart(Service *service)
         INIT_LOGE("start service %s fork failed!", service->name);
         return SERVICE_FAILURE;
     }
-    INIT_LOGI("service %s starting pid %d", service->name, pid);
+    INIT_LOGI("Service %s(pid %d) started", service->name, pid);
     service->pid = pid;
     NotifyServiceChange(service, SERVICE_STARTED);
     return SERVICE_SUCCESS;
@@ -414,8 +414,6 @@ int ServiceStop(Service *service)
         "stop service %s pid %d failed! err %d.", service->name, service->pid, errno);
     NotifyServiceChange(service, SERVICE_STOPPING);
     INIT_LOGI("stop service %s, pid %d.", service->name, service->pid);
-    service->pid = -1;
-    NotifyServiceChange(service, SERVICE_STOPPED);
     return SERVICE_SUCCESS;
 }
 

services/init/init_config.c

@@ -34,7 +34,7 @@ static void ParseInitCfgContents(const char *cfgName, const cJSON *root)
 int ParseInitCfg(const char *configFile, void *context)
 {
     UNUSED(context);
-    INIT_LOGI("ParseInitCfg %s", configFile);
+    INIT_LOGV("Parse init configs from %s", configFile);
     static const char *excludeCfg[] = {
         "/system/etc/init/weston.cfg"
     };

services/init/init_group_manager.c

@@ -49,7 +49,6 @@ static int ParseGroupCfgItem(cJSON *root, int type, const char *itemName)
 {
     int itemNumber = 0;
     cJSON *json = GetArrayItem(root, &itemNumber, itemName);
-    INIT_LOGI("ParseGroupCfgItem %s itemNumber %d", itemName, itemNumber);
     if (json == NULL) {
         return 0;
     }
@@ -189,7 +188,7 @@ void InitServiceSpace(void)
         int ret = GetProcCmdlineValue(BOOT_GROUP_NAME, data,
             g_initWorkspace.groupModeStr, sizeof(g_initWorkspace.groupModeStr));
         if (ret != 0) {
-            INIT_LOGE("%s", "Failed to get boot group");
+            INIT_LOGV("Failed to get boot group");
             if (GetBootModeFromMisc() == GROUP_CHARGE) {
                 strcpy_s(g_initWorkspace.groupModeStr, sizeof(g_initWorkspace.groupModeStr), "device.charge.group");
             }

services/init/init_service_file.c

@@ -39,7 +39,7 @@ static int CreateFile(ServiceFile *file)
         INIT_ERROR_CHECK(strncpy_s(path, strlen(file->fileName) + 1, file->fileName, strlen(file->fileName)) >= 0,
             return -1, "Failed strncpy_s err=%d", errno);
     }
-    INIT_LOGI("File path =%s . file flags =%d, file perm =%u ", path, file->flags, file->perm);
+    INIT_LOGV("File path =%s . file flags =%d, file perm =%u ", path, file->flags, file->perm);
     if (file->fd >= 0) {
         close(file->fd);
         file->fd = -1;
@@ -64,7 +64,6 @@ static int SetFileEnv(int fd, const char *pathName)
     char val[MAX_FILE_FD_LEN] = { 0 };
     INIT_ERROR_CHECK(snprintf_s(val, sizeof(val), sizeof(val) - 1, "%d", fd) >= 0, return -1,
         "Failed snprintf_s err=%d", errno);
-    INIT_LOGE("Set file env pubName =%s, val =%s.", pubName, val);
     int ret = setenv(pubName, val, 1);
     INIT_ERROR_CHECK(ret >= 0, return -1, "Failed setenv err=%d ", errno);
     fcntl(fd, F_SETFD, 0);

services/init/init_service_manager.c

@@ -213,7 +213,7 @@ static int GetServiceArgs(const cJSON *argJson, const char *name, int maxCount,
         INIT_ERROR_CHECK(curParam != NULL, return SERVICE_FAILURE, "Invalid arg %d", i);
         INIT_ERROR_CHECK(strlen(curParam) <= MAX_ONE_ARG_LEN, return SERVICE_FAILURE, "Arg %s is tool long", curParam);
         args->argv[i] = strdup(curParam);
-        INIT_ERROR_CHECK(args->argv[i] != NULL, return SERVICE_FAILURE, "Failed to dupstring %s", curParam);
+        INIT_ERROR_CHECK(args->argv[i] != NULL, return SERVICE_FAILURE, "Failed to duplicate argument %s", curParam);
     }
     return SERVICE_SUCCESS;
 }
@@ -265,13 +265,13 @@ static int GetServiceGids(const cJSON *curArrItem, Service *curServ)
         free(curServ->servPerm.gIDArray);
     }
     curServ->servPerm.gIDArray = (gid_t *)malloc(sizeof(gid_t) * gidCount);
-    INIT_ERROR_CHECK(curServ->servPerm.gIDArray != NULL, return SERVICE_FAILURE, "Failed to malloc");
+    INIT_ERROR_CHECK(curServ->servPerm.gIDArray != NULL, return SERVICE_FAILURE, "Failed to malloc err=%d", errno);
     curServ->servPerm.gIDCnt = gidCount;
 
     gid_t gid;
     if (!cJSON_IsArray(arrItem)) {
         int ret = GetGid(arrItem, &gid, curServ);
-        INIT_ERROR_CHECK(ret == 0, return SERVICE_FAILURE, "Failed to gid");
+        INIT_ERROR_CHECK(ret == 0, return SERVICE_FAILURE, "Parse service %s gid failed.", curServ->name);
         curServ->servPerm.gIDArray[0] = gid;
         return SERVICE_SUCCESS;
     }
@@ -280,7 +280,7 @@ static int GetServiceGids(const cJSON *curArrItem, Service *curServ)
         cJSON *item = cJSON_GetArrayItem(arrItem, i);
         int ret = GetGid(item, &gid, curServ);
         if (ret != 0) {
-            INIT_LOGE("parse service %s %d gid failed skip this", curServ->name, i);
+            INIT_LOGW("Parse service %s gid failed from item %s.", curServ->name, cJSON_Print(item));
             continue;
         }
         curServ->servPerm.gIDArray[gidArrayIndex++] = gid;
@@ -1071,7 +1071,7 @@ static Service *GetServiceByExtServName(const char *fullServName)
 
 void StartServiceByName(const char *servName)
 {
-    INIT_LOGI("StartServiceByName Service %s", servName);
+    INIT_LOGI("Start service %s", servName);
     Service *service = GetServiceByName(servName);
     if (service == NULL) {
         service = GetServiceByExtServName(servName);
@@ -1094,7 +1094,7 @@ void StopServiceByName(const char *servName)
     INIT_ERROR_CHECK(service != NULL, return, "Cannot find service %s.", servName);
 
     if (ServiceStop(service) != SERVICE_SUCCESS) {
-        INIT_LOGE("Service %s start failed!", servName);
+        INIT_LOGE("Service %s stop failed!", servName);
     }
     return;
 }

services/init/init_service_socket.c

@@ -123,8 +123,8 @@ static int SetSocketOptionAndBind(ServiceSocket *sockopt)
 
 static int CreateSocket(ServiceSocket *sockopt)
 {
-    INIT_ERROR_CHECK(sockopt != NULL, return SERVICE_FAILURE, "Invalid socket opt");
-    INIT_LOGI("name: %s, family: %d, type: %u, protocol: %d, perm: %u, uid: %u, gid: %u, option: %u",
+    INIT_ERROR_CHECK(sockopt != NULL, return SERVICE_FAILURE, "Invalid socket options");
+    INIT_LOGV("Socket name: %s, family: %d, type: %u, protocol: %d, perm: %u, uid: %u, gid: %u, option: %u",
         sockopt->name, sockopt->family, sockopt->type, sockopt->protocol,
         sockopt->perm, sockopt->uid,    sockopt->gid,  sockopt->option);
     if (sockopt->sockFd >= 0) {
@@ -192,7 +192,7 @@ int SocketAddWatcher(ServiceWatcher *watcherHandle, Service *service, int fd)
     info.events = Event_Read;
     info.processEvent = ProcessWatchEvent_;
     int ret = LE_StartWatcher(LE_GetDefaultLoop(), &handle, &info, service);
-    INIT_LOGI("Start to monitor socket, fd:%d service name:%s", fd, service->name);
+    INIT_LOGI("Watcher socket fd %d for service %s", fd, service->name);
     *watcherHandle = (ServiceWatcher)handle;
     return ret;
 }

services/init/lite/init_service.c

@@ -66,21 +66,8 @@ int ServiceExec(const Service *service)
 {
     INIT_ERROR_CHECK(service != NULL && service->pathArgs.count > 0,
         return SERVICE_FAILURE, "Exec service failed! null ptr.");
-    INIT_LOGI("service->name is %s ", service->name);
-    char sockEnvName[MAX_ENV_NAME] = {0};
-    char sockEnvValue[MAX_ENV_NAME] = {0};
-    if (service->socketCfg != NULL) {
-        INIT_ERROR_CHECK(snprintf_s(sockEnvName, MAX_ENV_NAME, MAX_ENV_NAME - 1, "OHOS_SOCKET_%s",
-            service->socketCfg->name) != -1,
-            return SERVICE_FAILURE, "format socket env name failed!");
-        INIT_ERROR_CHECK(snprintf_s(sockEnvValue, MAX_ENV_NAME, MAX_ENV_NAME - 1, "%d",
-            service->socketCfg->sockFd) != -1,
-            return SERVICE_FAILURE, "format socket env value failed!");
-    }
-    INIT_CHECK_ONLY_ELOG(setenv(sockEnvName, sockEnvValue, 1) == 0, "DoExport: set %s with %s failed: %d",
-        sockEnvName, sockEnvValue, errno);
     if (execv(service->pathArgs.argv[0], service->pathArgs.argv) != 0) {
-        INIT_LOGE("service %s execv failed! err %d.", service->name, errno);
+        INIT_LOGE("Service %s execv failed! err=%d.", service->name, errno);
         return errno;
     }
     return SERVICE_SUCCESS;

services/init/standard/init.c

@@ -46,11 +46,6 @@
 #include "fd_holder_internal.h"
 #include "bootstage.h"
 
-typedef struct HOOK_TIMING_STAT {
-    struct timespec startTime;
-    struct timespec endTime;
-} HOOK_TIMING_STAT;
-
 static int FdHolderSockInit(void)
 {
     int sock = -1;
@@ -206,6 +201,7 @@ static void StartInitSecondStage(void)
     KeyCtrlGetKeyringId(KEY_SPEC_SESSION_KEYRING, 1);
 
 #ifndef DISABLE_INIT_TWO_STAGES
+    INIT_LOGI("Start init second stage.");
     SwitchRoot("/usr");
     // Execute init second stage
     char * const args[] = {
@@ -222,6 +218,7 @@ static void StartInitSecondStage(void)
 
 void SystemPrepare(void)
 {
+    INIT_LOGI("Start init first stage.");
     MountBasicFs();
     CreateDeviceNode();
     LogInit();
@@ -252,17 +249,7 @@ HOOK_MGR *GetBootStageHookMgr()
     return bootStageHookMgr;
 }
 
-HOOK_TIMING_STAT g_bootJob = {0};
-static long long  InitDiffTime(HOOK_TIMING_STAT *stat)
-{
-    long long diff = (long long)((stat->endTime.tv_sec - stat->startTime.tv_sec) * 1000000); // 1000000 1000ms
-    if (stat->endTime.tv_nsec > stat->startTime.tv_nsec) {
-        diff += (stat->endTime.tv_nsec - stat->startTime.tv_nsec) / 1000; // 1000 ms
-    } else {
-        diff -= (stat->startTime.tv_nsec - stat->endTime.tv_nsec) / 1000; // 1000 ms
-    }
-    return diff;
-}
+INIT_TIMING_STAT g_bootJob = {0};
 
 static void BootStateChange(int start, const char *content)
 {
@@ -297,13 +284,13 @@ static void InitLoadParamFiles(void)
 
 static void InitPreHook(const HOOK_INFO *hookInfo, void *executionContext)
 {
-    HOOK_TIMING_STAT *stat = (HOOK_TIMING_STAT *)executionContext;
+    INIT_TIMING_STAT *stat = (INIT_TIMING_STAT *)executionContext;
     clock_gettime(CLOCK_MONOTONIC, &(stat->startTime));
 }
 
 static void InitPostHook(const HOOK_INFO *hookInfo, void *executionContext, int executionRetVal)
 {
-    HOOK_TIMING_STAT *stat = (HOOK_TIMING_STAT *)executionContext;
+    INIT_TIMING_STAT *stat = (INIT_TIMING_STAT *)executionContext;
     clock_gettime(CLOCK_MONOTONIC, &(stat->endTime));
     long long diff = InitDiffTime(stat);
     INIT_LOGI("Executing hook [%d:%d:%p] cost [%lld]us, return %d.",
@@ -352,7 +339,7 @@ static void TriggerServices(int startMode)
 
 void SystemConfig(void)
 {
-    HOOK_TIMING_STAT timingStat;
+    INIT_TIMING_STAT timingStat;
     HOOK_EXEC_OPTIONS options;
 
     options.flags = 0;

services/init/standard/init_cmdexecutor.c

@@ -29,7 +29,7 @@ static int g_cmdId = 0;
 int AddCmdExecutor(const char *cmdName, CmdExecutor execCmd)
 {
     INIT_ERROR_CHECK(cmdName != NULL, return -1, "Invalid input param");
-    INIT_LOGI("AddCmdExecutor '%s'", cmdName);
+    INIT_LOGV("Add command '%s' executor.", cmdName);
     PluginCmd *cmd = NULL;
     InitGroupNode *groupNode = GetGroupNode(NODE_TYPE_CMDS, cmdName);
     if (groupNode == NULL) {
@@ -158,6 +158,7 @@ void PluginExecCmdByCmdIndex(int index, const char *cmdContent)
         return;
     }
     PluginCmd *cmd = groupNode->data.cmd;
+    INIT_LOGV("Command: %s cmdContent: %s", cmd->name, cmdContent);
     PluginExecCmd_(cmd, cmdContent);
 }
 
@@ -186,6 +187,5 @@ const char *PluginGetCmdIndex(const char *cmdStr, int *index)
     hashCode = (hashCode < 0) ? -hashCode : hashCode;
     hashCode = hashCode % GROUP_HASHMAP_BUCKET;
     *index = ((hashCode + 1) << 16) | cmd->cmdId; // 16 left shift
-    INIT_LOGI("PluginGetCmdIndex content: %s index %d", cmd->name, *index);
     return cmd->name;
 }

services/init/standard/init_cmds.c

@@ -92,7 +92,7 @@ int GetParamValue(const char *symValue, unsigned int symLen, char *paramValue, u
 static void SyncExecCommand(int argc, char * const *argv)
 {
     INIT_CHECK(!(argc == 0 || argv == NULL || argv[0] == NULL), return);
-    INIT_LOGI("sync exec: %s", argv[0]);
+    INIT_LOGI("Sync exec: %s", argv[0]);
     pid_t pid = fork();
     INIT_ERROR_CHECK(!(pid < 0), return, "Fork new process to format failed: %d", errno);
     if (pid == 0) {
@@ -105,7 +105,7 @@ static void SyncExecCommand(int argc, char * const *argv)
         INIT_LOGE("Failed to wait pid %d, errno %d", pid, errno);
         return;
     }
-    INIT_LOGI("sync exec: %s result %d %d", argv[0], WEXITSTATUS(status), WIFEXITED(status));
+    INIT_LOGI("Sync exec: %s result %d %d", argv[0], WEXITSTATUS(status), WIFEXITED(status));
     return;
 }
 
@@ -424,17 +424,18 @@ static bool InitFscryptPolicy(void)
 
 static void DoInitGlobalKey(const struct CmdArgs *ctx)
 {
+    INIT_LOGV("Do init global key start");
     if (ctx == NULL || ctx->argc != 1) {
-        INIT_LOGE("DoInitGlobalKey: para invalid");
+        INIT_LOGE("Parameter is invalid");
         return;
     }
     const char *dataDir = "/data";
     if (strncmp(ctx->argv[0], dataDir, strlen(dataDir)) != 0) {
-        INIT_LOGE("DoInitGlobalKey: not data partitation");
+        INIT_LOGE("Not data partitation");
         return;
     }
     if (!InitFscryptPolicy()) {
-        INIT_LOGI("DoInitGlobalKey:init fscrypt failed,not enable fscrypt");
+        INIT_LOGW("Init fscrypt failed, not enable fscrypt");
         return;
     }
 
@@ -451,7 +452,7 @@ static void DoInitGlobalKey(const struct CmdArgs *ctx)
 static void DoInitMainUser(const struct CmdArgs *ctx)
 {
     if (ctx == NULL) {
-        INIT_LOGE("DoInitMainUser: para invalid");
+        INIT_LOGE("Do init main user: para invalid");
         return;
     }
 
@@ -468,7 +469,7 @@ static void DoInitMainUser(const struct CmdArgs *ctx)
 static void DoMkswap(const struct CmdArgs *ctx)
 {
     if (ctx == NULL) {
-        INIT_LOGE("DoMkswap: para invalid");
+        INIT_LOGE("Parameter is invalid");
         return;
     }
     char *const argv[] = {
@@ -483,7 +484,7 @@ static void DoMkswap(const struct CmdArgs *ctx)
 static void DoSwapon(const struct CmdArgs *ctx)
 {
     if (ctx == NULL) {
-        INIT_LOGE("DoSwapon: para invalid");
+        INIT_LOGE("Parameter is invalid");
         return;
     }
     char *const argv[] = {
@@ -497,7 +498,7 @@ static void DoSwapon(const struct CmdArgs *ctx)
 
 static void DoMkSandbox(const struct CmdArgs *ctx)
 {
-    INIT_LOGI("DoMkSandbox: start");
+    INIT_LOGV("Do make sandbox start");
     if ((ctx == NULL) || (ctx->argc != 1)) {
         INIT_LOGE("Call DoMkSandbox with invalid arguments");
         return;

services/init/standard/init_service.c

@@ -40,7 +40,7 @@ static bool g_enableSandbox = false;
 
 void NotifyServiceChange(Service *service, int status)
 {
-    INIT_LOGI("NotifyServiceChange %s %d to %d", service->name, service->status, status);
+    INIT_LOGV("Notify service %s change from %d to %d", service->name, service->status, status);
     service->status = status;
     INIT_CHECK(status != SERVICE_IDLE, return);
     char paramName[PARAM_NAME_LEN_MAX] = { 0 };
@@ -98,8 +98,11 @@ int SetAccessToken(const Service *service)
 {
     INIT_ERROR_CHECK(service != NULL, return SERVICE_FAILURE, "service is null");
     int ret = SetSelfTokenID(service->tokenId);
-    INIT_LOGI("%s: token id %lld, set token id result %d", service->name, service->tokenId, ret);
-    return ret == 0 ? SERVICE_SUCCESS : SERVICE_FAILURE;
+    if (ret != 0) {
+        INIT_LOGV("Set service %s token id %lld failed.", service->name, service->tokenId);
+        return SERVICE_FAILURE;
+    }
+    return SERVICE_SUCCESS;
 }
 
 void GetAccessToken(void)
@@ -125,7 +128,6 @@ void GetAccessToken(void)
                 service->name,
                 apl,
             };
-
             uint64_t tokenId = GetAccessTokenId(&nativeTokenInfoParams);
             INIT_CHECK_ONLY_ELOG(tokenId  != 0,
                 "Get totken id %lld of service \' %s \' failed", tokenId, service->name);

services/init/standard/init_signal_handler.c

@@ -35,18 +35,16 @@ static void ProcessSignal(const struct signalfd_siginfo *siginfo)
                 if (sigPID <= 0) {
                     break;
                 }
+                Service* service = GetServiceByPid(sigPID);
                 // check child process exit status
                 if (WIFSIGNALED(procStat)) {
                     INIT_LOGE("Child process %d exit with signal: %d", sigPID, WTERMSIG(procStat));
                 }
                 if (WIFEXITED(procStat)) {
-                    INIT_LOGE("Child process %d exit with code : %d", sigPID, WEXITSTATUS(procStat));
+                    INIT_LOGE("Child process %s(pid %d) exit with code : %d",
+                        service == NULL ? "Unknown" : service->name, sigPID, WEXITSTATUS(procStat));
                 }
                 CmdServiceProcessDelClient(sigPID);
-                Service* service = GetServiceByPid(sigPID);
-                INIT_LOGI("SigHandler, SIGCHLD received, Service:%s pid:%d uid:%d status:%d.",
-                    service == NULL ? "Unknown" : service->name,
-                    sigPID, siginfo->ssi_uid, procStat);
                 CheckWaitPid(sigPID);
                 ServiceReap(service);
             }

services/modules/reboot/reboot.c

@@ -128,12 +128,12 @@ static void RebootAdpExit(void)
 
 MODULE_CONSTRUCTOR(void)
 {
-    PLUGIN_LOGI("RebootAdp init now ...");
+    PLUGIN_LOGI("Reboot adapter plug-in init now ...");
     RebootAdpInit();
 }
 
 MODULE_DESTRUCTOR(void)
 {
-    PLUGIN_LOGI("RebootAdp exit now ...");
+    PLUGIN_LOGI("Reboot adapter plug-in exit now ...");
     RebootAdpExit();
 }

services/modules/selinux/selinux_adp.c

@@ -52,7 +52,7 @@ static int SetServiceContent(int id, const char *name, int argc, const char **ar
             PLUGIN_LOGE("failed to set service %s's secon (%s).", argv[0], (char *)data->data);
             _exit(PROCESS_EXIT_CODE);
         } else {
-            PLUGIN_LOGI("Set content %s to %s.", (char *)data->data, argv[0]);
+            PLUGIN_LOGV("Set content %s to %s.", (char *)data->data, argv[0]);
         }
     } else {
         PLUGIN_CHECK(!(setexeccon("u:r:limit_domain:s0") < 0), _exit(PROCESS_EXIT_CODE),
@@ -95,12 +95,12 @@ static void SelinuxAdpExit(void)
 
 MODULE_CONSTRUCTOR(void)
 {
-    PLUGIN_LOGI("SelinuxAdp init now ...");
+    PLUGIN_LOGI("Selinux adapter plug-in init now ...");
     SelinuxAdpInit();
 }
 
 MODULE_DESTRUCTOR(void)
 {
-    PLUGIN_LOGI("SelinuxAdp exit now ...");
+    PLUGIN_LOGI("Selinux adapter plug-in exit now ...");
     SelinuxAdpExit();
 }
\ No newline at end of file

services/param/adapter/param_dac.c

@@ -195,7 +195,7 @@ static int DacGetParamSecurityLabel(const char *path)
             ProcessParamFile(fileName, NULL);
         }
     }
-    PARAM_LOGI("DacGetParamSecurityLabel path %s %d", path, count);
+    PARAM_LOGV("Get parameter security label dac number is %d, from %s.", count, path);
     free(fileName);
     closedir(pDir);
     return 0;

services/param/adapter/param_persistadp.c

@@ -42,7 +42,7 @@ static int LoadPersistParam()
     if (fp == NULL) {
         tmpPath = (updaterMode == 0) ? PARAM_PERSIST_SAVE_PATH : "/param/persist_parameters";
         fp = fopen(tmpPath, "r");
-        PARAM_LOGI("LoadPersistParam open file %s", PARAM_PERSIST_SAVE_PATH);
+        PARAM_LOGI("Load persist param, from file %s", tmpPath);
     }
     PARAM_CHECK(fp != NULL, return -1, "No valid persist parameter file %s", PARAM_PERSIST_SAVE_PATH);
 

services/param/adapter/param_selinux.c

@@ -202,7 +202,7 @@ static int SelinuxGetAllLabel(int readOnly)
     if (readOnly == 0) {
         SetSelinuxFileCon(WORKSPACE_NAME_DEF_SELINUX, WORKSPACE_NAME_DEF_SELINUX);
     }
-    PARAM_LOGI("SelinuxGetAllLabel count %d", count);
+    PARAM_LOGV("Selinux get all label counts %d.", count);
     return 0;
 }
 

services/param/base/param_base.c

@@ -75,7 +75,7 @@ static int InitParamSecurity(ParamWorkSpace *workSpace,
     }
     ret = paramSecurityOps->securityCheckFilePermission(&workSpace->securityLabel, PARAM_STORAGE_PATH, op);
     PARAM_CHECK(ret == 0, return PARAM_CODE_INVALID_NAME, "No permission to read file %s", PARAM_STORAGE_PATH);
-    PARAM_LOGI("InitParamSecurity %s success", paramSecurityOps->name);
+    PARAM_LOGI("Init parameter %s success", paramSecurityOps->name);
     return 0;
 }
 
@@ -107,7 +107,6 @@ static int CheckNeedInit(int onlyRead, const PARAM_WORKSPACE_OPS *ops)
         g_paramWorkSpace.ops.setfilecon = ops->setfilecon;
 #endif
     }
-    PARAM_LOGI("InitParamWorkSpace %x", g_paramWorkSpace.flags);
     if (PARAM_TEST_FLAG(g_paramWorkSpace.flags, WORKSPACE_FLAGS_INIT)) {
         return 0;
     }
@@ -225,7 +224,7 @@ INIT_INNER_API ParamWorkSpace *GetParamWorkSpace(void)
 
 int SystemReadParam(const char *name, char *value, uint32_t *len)
 {
-    PARAM_WORKSPACE_CHECK(&g_paramWorkSpace, return -1, "Invalid space");
+    PARAM_WORKSPACE_CHECK(&g_paramWorkSpace, return -1, "Param workspace has not init.");
     PARAM_CHECK(name != NULL && len != NULL && strlen(name) > 0, return -1, "The name or value is null");
     ParamHandle handle = 0;
     int ret = ReadParamWithCheck(name, DAC_READ, &handle);

services/param/linux/param_request.c

@@ -134,7 +134,10 @@ static int StartRequest(int clientFd, ParamMessage *request, int timeout)
 {
     int ret = 0;
     ssize_t sendLen = send(clientFd, (char *)request, request->msgSize, 0);
-    PARAM_CHECK(sendLen >= 0, return PARAM_CODE_FAIL_CONNECT, "Failed to send message");
+    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);
     if (ret == 0) {

services/param/linux/param_service.c

@@ -95,7 +95,7 @@ static int SendResponseMsg(ParamTaskPtr worker, const ParamMessage *msg, int res
     response->result = result;
     response->msg.msgSize = sizeof(ParamResponseMessage);
     ParamTaskSendMsg(worker, (ParamMessage *)response);
-    PARAM_LOGI("SendResponseMsg msgId %d result %d", msg->id.msgId, result);
+    PARAM_LOGI("Send response msg msgId %d result %d", msg->id.msgId, result);
     return 0;
 }
 
@@ -172,7 +172,7 @@ static int HandleParamSet(const ParamTaskPtr worker, const ParamMessage *msg)
     srcLabel.cred.uid = cr.uid;
     srcLabel.cred.pid = cr.pid;
     srcLabel.cred.gid = cr.gid;
-    PARAM_LOGI("HandleParamSet msgId %d pid %d key: %s", msg->id.msgId, cr.pid, msg->key);
+    PARAM_LOGI("Handle set param msgId %d pid %d key: %s", msg->id.msgId, cr.pid, msg->key);
     int ret = SystemSetParam(msg->key, valueContent->content, &srcLabel);
     return SendResponseMsg(worker, msg, ret);
 }
@@ -364,7 +364,6 @@ static void LoadSelinuxLabel(void)
     // load security label
 #ifdef PARAM_SUPPORT_SELINUX
     ParamSecurityOps *ops = GetParamSecurityOps(PARAM_SECURITY_SELINUX);
-    PARAM_LOGI("load selinux label %p", ops->securityGetLabel);
     if (ops != NULL && ops->securityGetLabel != NULL) {
         ops->securityGetLabel(NULL);
     }

services/param/manager/param_manager.c

@@ -348,7 +348,7 @@ INIT_LOCAL_API int CheckParameterSet(const char *name,
         }
 #if !(defined __LITEOS_A__ || defined __LITEOS_M__)
         // do hook cmd
-        PARAM_LOGV("CheckParameterSet realKey %s cmd: '%s' value: %s",
+        PARAM_LOGV("Check parameter settings realKey %s cmd: '%s' value: %s",
             serviceInfo->realKey, serviceInfo->cmdName, (char *)serviceInfo->realKey + serviceInfo->valueOffset);
         DoCmdByName(serviceInfo->cmdName, (char *)serviceInfo->realKey + serviceInfo->valueOffset);
 #endif

services/param/manager/param_persist.c

@@ -185,7 +185,6 @@ INIT_LOCAL_API int WritePersistParam(const char *name, const char *value)
     // for linux, start timer after set persist parameter
     // for liteos-a, start timer in init to check and save parameter
 #ifdef PARAM_SUPPORT_REAL_CHECK
-    PARAM_LOGI("WritePersistParam start check ");
     if (!PARAM_TEST_FLAG(g_persistWorkSpace.flags, WORKSPACE_FLAGS_LOADED)) {
         PARAM_LOGE("Can not save persist param before load %s ", name);
         return 0;

services/param/manager/param_server.c

@@ -46,14 +46,14 @@ static int CommonDealFun(const char *name, const char *value, int res)
 {
     int ret = 0;
     if (res == 0) {
-        PARAM_LOGI("Add param from cmdline %s %s", name, value);
+        PARAM_LOGV("Add param from cmdline %s %s", name, value);
         ret = CheckParamName(name, 0);
-        PARAM_CHECK(ret == 0, return ret, "Invalid name %s", name);
-        PARAM_LOGV("**** name %s, value %s", name, value);
+        PARAM_CHECK(ret == 0, return ret, "Invalid param name %s", name);
+        PARAM_LOGV("Param name %s, value %s", name, value);
         ret = WriteParam(name, value, NULL, 0);
         PARAM_CHECK(ret == 0, return ret, "Failed to write param %s %s", name, value);
     } else {
-        PARAM_LOGE("Can not find arrt %s", name);
+        PARAM_LOGE("Get %s parameter value is null.", name);
     }
     return ret;
 }
@@ -182,7 +182,7 @@ static int LoadDefaultParam_(const char *fileName, uint32_t mode,
     }
     (void)fclose(fp);
     free(buffer);
-    PARAM_LOGI("Load parameters success %s total %u", fileName, paramNum);
+    PARAM_LOGV("Load %u default parameters success from %s.", paramNum, fileName);
     return 0;
 }
 
@@ -201,7 +201,7 @@ int LoadParamsFile(const char *fileName, bool onlyAdd)
 int LoadDefaultParams(const char *fileName, uint32_t mode)
 {
     PARAM_CHECK(fileName != NULL, return -1, "Invalid filename for load");
-    PARAM_LOGI("load default parameters %s.", fileName);
+    PARAM_LOGI("Load default parameters from %s.", fileName);
     struct stat st;
     if ((stat(fileName, &st) == 0) && !S_ISDIR(st.st_mode)) {
         (void)ProcessParamFile(fileName, &mode);

services/param/trigger/trigger_processor.c

@@ -32,7 +32,7 @@ static TriggerWorkSpace g_triggerWorkSpace = {};
 static int DoTriggerExecute_(const TriggerNode *trigger, const char *content, uint32_t size)
 {
     PARAM_CHECK(trigger != NULL, return -1, "Invalid trigger");
-    PARAM_LOGI("DoTriggerExecute_ trigger %s type: %d", GetTriggerName(trigger), trigger->type);
+    PARAM_LOGV("Do execute trigger %s type: %d", GetTriggerName(trigger), trigger->type);
     PARAM_CHECK(trigger->type <= TRIGGER_UNKNOW, return -1, "Invalid trigger type %d", trigger->type);
     CommandNode *cmd = GetNextCmdNode((JobNode *)trigger, NULL);
     while (cmd != NULL) {
@@ -53,7 +53,7 @@ static int DoTriggerCheckResult(TriggerNode *trigger, const char *content, uint3
         return 0;
     }
     TRIGGER_SET_FLAG(trigger, TRIGGER_FLAGS_QUEUE);
-    PARAM_LOGI("Add trigger %s to execute queue", GetTriggerName(trigger));
+    PARAM_LOGV("Add trigger %s to execute queue", GetTriggerName(trigger));
     ExecuteQueuePush(&g_triggerWorkSpace, trigger);
     return 0;
 }
@@ -368,11 +368,11 @@ void DoTriggerExec(const char *triggerName)
     PARAM_CHECK(triggerName != NULL, return, "Invalid param");
     JobNode *trigger = GetTriggerByName(&g_triggerWorkSpace, triggerName);
     if (trigger != NULL && !TRIGGER_IN_QUEUE((TriggerNode *)trigger)) {
-        PARAM_LOGI("DoTriggerExec trigger %s", trigger->name);
+        PARAM_LOGV("Trigger job %s", trigger->name);
         TRIGGER_SET_FLAG((TriggerNode *)trigger, TRIGGER_FLAGS_QUEUE);
         ExecuteQueuePush(&g_triggerWorkSpace, (TriggerNode *)trigger);
     } else {
-        PARAM_LOGE("Can not find trigger %s", triggerName);
+        PARAM_LOGW("Can not find trigger %s", triggerName);
     }
 }
 

services/utils/init_utils.c

@@ -511,8 +511,8 @@ int InUpdaterMode(void)
 #ifdef OHOS_LITE
     return 0;
 #else
-    const char * const updaterExecutabeFile = "/bin/updater";
-    if (access(updaterExecutabeFile, X_OK) == 0) {
+    const char * const updaterExecutableFile = "/bin/updater";
+    if (access(updaterExecutableFile, X_OK) == 0) {
         return 1;
     } else {
         return 0;

ueventd/ueventd.c

@@ -243,7 +243,7 @@ void ParseUeventMessage(const char *buffer, ssize_t length, struct Uevent *ueven
         return;
     }
 
-    // reset parititon number, major and minor.
+    // reset partititon number, major and minor.
     uevent->partitionNum = -1;
     uevent->major = -1;
     uevent->minor = -1;

ueventd/ueventd_device_handler.c

@@ -74,9 +74,7 @@ static void CreateSymbolLinks(const char *deviceNode, char **symLinks)
         errno = 0;
         int rc = symlink(deviceNode, linkName);
         if (rc != 0) {
-            if (errno == EEXIST) {
-                INIT_LOGW("Link \" %s \" already linked to other target", linkName);
-            } else {
+            if (errno != EEXIST) {
                 INIT_LOGE("Failed to link \" %s \" to \" %s \", err = %d", deviceNode, linkName, errno);
             }
         }

ueventd/ueventd_main.c

@@ -68,7 +68,7 @@ int main(int argc, char **argv)
         return -1;
     }
     if (access(UEVENTD_FLAG, F_OK)) {
-        INIT_LOGI("ueventd first start to trigger");
+        INIT_LOGI("Ueventd started, trigger uevent");
         RetriggerUevent(ueventSockFd, NULL, 0); // Not require boot devices
         int fd = open(UEVENTD_FLAG, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
         if (fd < 0) {

ueventd/ueventd_read_cfg.c

@@ -311,7 +311,7 @@ bool IsMatch(const char *target, const char *pattern)
         }
 
         if (*p == '\0') {
-            return !reMatch ? false : true;
+            return reMatch;
         }
 
         if (*p == '*') {
@@ -335,7 +335,7 @@ bool IsMatch(const char *target, const char *pattern)
     while (*p == '*') {
         p++;
     }
-    return (*p == '\0') ? true : false;
+    return (*p == '\0');
 }
 
 struct DeviceUdevConf *GetDeviceUdevConfByDevNode(const char *devNode)

watchdog/init_watchdog.c

@@ -76,7 +76,7 @@ int main(int argc, const char *argv[])
     }
     gap = (gap > 0) ? gap : DEFAULT_GAP;
 
-    INIT_LOGI("watchdoge started (interval %d, margin %d), fd = %d\n", interval, gap, fd);
+    INIT_LOGI("Watchdog started (interval %d, margin %d), fd = %d\n", interval, gap, fd);
 #ifdef OHOS_LITE_WATCHDOG
 #ifndef LINUX_WATCHDOG
     if (setpriority(PRIO_PROCESS, 0, 14) != 0) { // 14 is process priority