!1453 增加ut分支覆盖率

Merge pull request !1453 from Mupceet/code_add_coverage_rate

device_info/device_info.cpp

@@ -42,7 +42,6 @@ int AclGetDevUdid(char *udid, int size)
 #else
     int ret = GetDevUdid_(udid, size);
 #endif
-    BEGET_LOGI("AclGetDevUdid %s", udid);
     return ret;
 }
 
@@ -64,7 +63,6 @@ const char *AclGetSerial(void)
         BEGET_ERROR_CHECK(ret == 0, return nullptr, "Failed to copy");
     }
 #endif
-    BEGET_LOGI("AclGetSerial %s", serialNumber);
     return serialNumber;
 }
 

device_info/device_info_kits.cpp

@@ -77,7 +77,7 @@ void DeviceInfoKits::FinishStartSASuccess(const sptr<IRemoteObject> &remoteObjec
 
 void DeviceInfoKits::FinishStartSAFailed()
 {
-    DINFO_LOGI("get deviceinfo sa failed.");
+    DINFO_LOGI("Get deviceinfo sa failed.");
     // get lock which wait_for release and send a notice
     std::unique_lock<std::mutex> lock(lock_);
     deviceInfoService_ = nullptr;

device_info/device_info_kits.h

@@ -18,10 +18,11 @@
 #include <mutex>
 #include "idevice_info.h"
 #include "singleton.h"
+#include "beget_ext.h"
 
 namespace OHOS {
 namespace device_info {
-class DeviceInfoKits final : public DelayedRefSingleton<DeviceInfoKits> {
+class INIT_LOCAL_API DeviceInfoKits final : public DelayedRefSingleton<DeviceInfoKits> {
     DECLARE_DELAYED_REF_SINGLETON(DeviceInfoKits);
 public:
     DISALLOW_COPY_AND_MOVE(DeviceInfoKits);

device_info/device_info_proxy.cpp

@@ -18,16 +18,33 @@
 #include "idevice_info.h"
 #include "parcel.h"
 #include "string_ex.h"
+#include "sysparam_errno.h"
 
 namespace OHOS {
 namespace device_info {
+int32_t DeviceInfoProxy::DeviceInfoSendRequest(uint32_t code,
+    MessageParcel &data, MessageParcel &reply, MessageOption &option)
+{
+#ifdef STARTUP_INIT_TEST
+    int ret = 0;
+#else
+    int ret = SYSPARAM_SYSTEM_ERROR;
+#endif
+    auto remote = Remote();
+    if (remote != nullptr) {
+        ret = remote->SendRequest(code, data, reply, option);
+    }
+    return ret;
+}
+
 int32_t DeviceInfoProxy::GetUdid(std::string& result)
 {
     MessageParcel data;
     MessageParcel reply;
     MessageOption option { MessageOption::TF_SYNC };
     data.WriteInterfaceToken(DeviceInfoProxy::GetDescriptor());
-    int32_t ret = Remote()->SendRequest(COMMAND_GET_UDID, data, reply, option);
+    int32_t ret = DeviceInfoSendRequest(COMMAND_GET_UDID, data, reply, option);
+    DINFO_LOGI("DeviceInfoProxy::GetUdid: %d", ret);
     DINFO_CHECK(ret == ERR_NONE, return ret, "getUdid failed, error code is %d", ret);
     result = Str16ToStr8(reply.ReadString16());
     return ERR_OK;
@@ -40,7 +57,8 @@ int32_t DeviceInfoProxy::GetSerialID(std::string& result)
     MessageOption option { MessageOption::TF_SYNC };
 
     data.WriteInterfaceToken(DeviceInfoProxy::GetDescriptor());
-    int32_t ret = Remote()->SendRequest(COMMAND_GET_SERIAL_ID, data, reply, option);
+    int32_t ret = DeviceInfoSendRequest(COMMAND_GET_SERIAL_ID, data, reply, option);
+    DINFO_LOGI("DeviceInfoProxy::GetSerialID: %d", ret);
     DINFO_CHECK(ret == ERR_NONE, return ret, "GetSerial failed, error code is %d", ret);
     result = Str16ToStr8(reply.ReadString16());
     return ERR_OK;

device_info/device_info_proxy.h

@@ -18,10 +18,11 @@
 
 #include "iremote_proxy.h"
 #include "idevice_info.h"
+#include "beget_ext.h"
 
 namespace OHOS {
 namespace device_info {
-class DeviceInfoProxy : public IRemoteProxy<IDeviceInfo> {
+class INIT_LOCAL_API DeviceInfoProxy : public IRemoteProxy<IDeviceInfo> {
 public:
     explicit DeviceInfoProxy(const sptr<IRemoteObject> &impl) : IRemoteProxy<IDeviceInfo>(impl) {}
     virtual ~DeviceInfoProxy() {}
@@ -29,6 +30,8 @@ public:
     int32_t GetUdid(std::string& result) override;
     int32_t GetSerialID(std::string& result) override;
 private:
+    int32_t DeviceInfoSendRequest(uint32_t code,
+        MessageParcel &data, MessageParcel &reply, MessageOption &option);
     static inline BrokerDelegator<DeviceInfoProxy> delegator_;
 };
 } // namespace system

device_info/device_info_stub.cpp

@@ -25,7 +25,6 @@
 #include "param_comm.h"
 #include "sysparam_errno.h"
 
-using std::u16string;
 namespace OHOS {
 using namespace Security;
 using namespace Security::AccessToken;
@@ -43,7 +42,7 @@ int32_t DeviceInfoStub::OnRemoteRequest(uint32_t code,
     int ret = ERR_FAIL;
     switch (code) {
         case COMMAND_GET_UDID: {
-            if (!CheckPermission(data, PERMISSION_UDID)) {
+            if (!CheckPermission(data, "ohos.permission.sec.ACCESS_UDID")) {
                 return SYSPARAM_PERMISSION_DENIED;
             }
             char localDeviceInfo[UDID_LEN] = {0};
@@ -53,7 +52,7 @@ int32_t DeviceInfoStub::OnRemoteRequest(uint32_t code,
             break;
         }
         case COMMAND_GET_SERIAL_ID: {
-            if (!CheckPermission(data, PERMISSION_UDID)) {
+            if (!CheckPermission(data, "ohos.permission.sec.ACCESS_UDID")) {
                 return SYSPARAM_PERMISSION_DENIED;
             }
             const char *serialNumber = GetSerial_();
@@ -98,10 +97,10 @@ int32_t DeviceInfoService::GetSerialID(std::string& result)
 
 void DeviceInfoService::OnStart(void)
 {
-    DINFO_LOGI("WatcherManager OnStart");
+    DINFO_LOGI("DeviceInfoService OnStart");
     bool res = Publish(this);
     if (!res) {
-        DINFO_LOGE("WatcherManager Publish failed");
+        DINFO_LOGE("DeviceInfoService Publish failed");
     }
     return;
 }

device_info/device_info_stub.h

@@ -41,9 +41,7 @@ public:
     ~DeviceInfoService() override {}
     int32_t GetUdid(std::string& result) override;
     int32_t GetSerialID(std::string& result) override;
-#ifndef STARTUP_INIT_TEST
 protected:
-#endif
     void OnStart(void) override;
     void OnStop(void) override;
     int Dump(int fd, const std::vector<std::u16string>& args) override;

device_info/idevice_info.h

@@ -33,7 +33,6 @@ public:
     static constexpr int COMMAND_GET_UDID = MIN_TRANSACTION_ID + 0;
     static constexpr int COMMAND_GET_SERIAL_ID = MIN_TRANSACTION_ID + 1;
     static constexpr int ERR_FAIL = -1;
-    const std::string PERMISSION_UDID = "ohos.permission.sec.ACCESS_UDID";
 };
 } // namespace device_info
 } // namespace OHOS

interfaces/innerkits/control_fd/control_fd.h

@@ -35,6 +35,12 @@ extern "C" {
 #define PTY_BUF_SIZE 4096
 #define PTY_PATH_SIZE 128
 
+#ifdef STARTUP_INIT_TEST
+#define CONTROL_FD_STATIC
+#else
+#define CONTROL_FD_STATIC static
+#endif
+
 typedef struct CmdService_ {
     TaskHandle serverTask;
     struct ListNode head;

interfaces/innerkits/control_fd/control_fd_client.c

@@ -23,7 +23,7 @@
 #include "control_fd.h"
 #include "securec.h"
 
-static void ProcessPtyWrite(const WatcherHandle taskHandle, int fd, uint32_t *events, const void *context)
+CONTROL_FD_STATIC void ProcessPtyWrite(const WatcherHandle taskHandle, int fd, uint32_t *events, const void *context)
 {
     if ((fd < 0) || (events == NULL) || (context == NULL)) {
         BEGET_LOGE("[control_fd] Invalid fifo write parameter");
@@ -43,7 +43,7 @@ static void ProcessPtyWrite(const WatcherHandle taskHandle, int fd, uint32_t *ev
     *events = Event_Read;
 }
 
-static void ProcessPtyRead(const WatcherHandle taskHandle, int fd, uint32_t *events, const void *context)
+CONTROL_FD_STATIC void ProcessPtyRead(const WatcherHandle taskHandle, int fd, uint32_t *events, const void *context)
 {
     if ((fd < 0) || (events == NULL) || (context == NULL)) {
         BEGET_LOGE("[control_fd] Invalid fifo read parameter");
@@ -63,17 +63,17 @@ static void ProcessPtyRead(const WatcherHandle taskHandle, int fd, uint32_t *eve
     *events = Event_Read;
 }
 
-static void CmdOnRecvMessage(const TaskHandle task, const uint8_t *buffer, uint32_t buffLen)
+CONTROL_FD_STATIC void CmdClientOnRecvMessage(const TaskHandle task, const uint8_t *buffer, uint32_t buffLen)
 {
     BEGET_LOGI("[control_fd] CmdOnRecvMessage %s len %d.", (char *)buffer, buffLen);
 }
 
-static void CmdOnConnectComplete(const TaskHandle client)
+CONTROL_FD_STATIC void CmdOnConnectComplete(const TaskHandle client)
 {
     BEGET_LOGI("[control_fd] CmdOnConnectComplete");
 }
 
-static void CmdOnClose(const TaskHandle task)
+CONTROL_FD_STATIC void CmdOnClose(const TaskHandle task)
 {
     BEGET_LOGI("[control_fd] CmdOnClose");
     CmdAgent *agent = (CmdAgent *)LE_GetUserData(task);
@@ -83,17 +83,17 @@ static void CmdOnClose(const TaskHandle task)
     LE_StopLoop(LE_GetDefaultLoop());
 }
 
-static void CmdDisConnectComplete(const TaskHandle client)
+CONTROL_FD_STATIC void CmdDisConnectComplete(const TaskHandle client)
 {
     BEGET_LOGI("[control_fd] CmdDisConnectComplete");
 }
 
-static void CmdOnSendMessageComplete(const TaskHandle task, const BufferHandle handle)
+CONTROL_FD_STATIC void CmdOnSendMessageComplete(const TaskHandle task, const BufferHandle handle)
 {
     BEGET_LOGI("[control_fd] CmdOnSendMessageComplete");
 }
 
-static CmdAgent *CmdAgentCreate(const char *server)
+CONTROL_FD_STATIC CmdAgent *CmdAgentCreate(const char *server)
 {
     if (server == NULL) {
         BEGET_LOGE("[control_fd] Invalid parameter");
@@ -108,7 +108,7 @@ static CmdAgent *CmdAgentCreate(const char *server)
     info.disConnectComplete = CmdDisConnectComplete;
     info.connectComplete = CmdOnConnectComplete;
     info.sendMessageComplete = CmdOnSendMessageComplete;
-    info.recvMessage = CmdOnRecvMessage;
+    info.recvMessage = CmdClientOnRecvMessage;
     LE_STATUS status = LE_CreateStreamClient(LE_GetDefaultLoop(), &task, &info);
     BEGET_ERROR_CHECK(status == 0, return NULL, "[control_fd] Failed create client");
     CmdAgent *agent = (CmdAgent *)LE_GetUserData(task);
@@ -117,7 +117,7 @@ static CmdAgent *CmdAgentCreate(const char *server)
     return agent;
 }
 
-static int SendCmdMessage(const CmdAgent *agent, uint16_t type, const char *cmd, const char *ptyName)
+CONTROL_FD_STATIC int SendCmdMessage(const CmdAgent *agent, uint16_t type, const char *cmd, const char *ptyName)
 {
     if ((agent == NULL) || (cmd == NULL) || (ptyName == NULL)) {
         BEGET_LOGE("[control_fd] Invalid parameter");
@@ -143,11 +143,12 @@ static int SendCmdMessage(const CmdAgent *agent, uint16_t type, const char *cmd,
     return 0;
 }
 
-static int InitPtyInterface(CmdAgent *agent, uint16_t type, const char *cmd)
+CONTROL_FD_STATIC int InitPtyInterface(CmdAgent *agent, uint16_t type, const char *cmd)
 {
     if ((cmd == NULL) || (agent == NULL)) {
         return -1;
     }
+#ifndef STARTUP_INIT_TEST
     // initialize terminal
     struct termios term;
     int ret = tcgetattr(STDIN_FILENO, &term);
@@ -181,6 +182,7 @@ static int InitPtyInterface(CmdAgent *agent, uint16_t type, const char *cmd)
         close(pfd); return -1, "[control_fd] Failed le_loop start watcher stdin read and write ptmx");
     ret = SendCmdMessage(agent, type, cmd, ptsbuffer);
     BEGET_ERROR_CHECK(ret == 0, close(pfd); return -1, "[control_fd] Failed send message");
+#endif
     return 0;
 }
 
@@ -192,11 +194,13 @@ void CmdClientInit(const char *socketPath, uint16_t type, const char *cmd)
     BEGET_LOGI("[control_fd] CmdAgentInit");
     CmdAgent *agent = CmdAgentCreate(socketPath);
     BEGET_ERROR_CHECK(agent != NULL, return, "[control_fd] Failed to create agent");
+#ifndef STARTUP_INIT_TEST
     int ret = InitPtyInterface(agent, type, cmd);
     if (ret != 0) {
         return;
     }
     LE_RunLoop(LE_GetDefaultLoop());
     LE_CloseLoop(LE_GetDefaultLoop());
+#endif
     BEGET_LOGI("Cmd Client exit ");
 }

interfaces/innerkits/control_fd/control_fd_service.c

@@ -32,7 +32,7 @@ static void OnClose(const TaskHandle task)
     OH_ListInit(&agent->item);
 }
 
-static void CmdOnRecvMessage(const TaskHandle task, const uint8_t *buffer, uint32_t buffLen)
+CONTROL_FD_STATIC void CmdOnRecvMessage(const TaskHandle task, const uint8_t *buffer, uint32_t buffLen)
 {
     if (buffer == NULL) {
         return;
@@ -46,7 +46,7 @@ static void CmdOnRecvMessage(const TaskHandle task, const uint8_t *buffer, uint3
         BEGET_LOGE("[control_fd] Received msg is invaild");
         return;
     }
-
+#ifndef STARTUP_INIT_TEST
     agent->pid = fork();
     if (agent->pid == 0) {
         OpenConsole();
@@ -68,10 +68,11 @@ static void CmdOnRecvMessage(const TaskHandle task, const uint8_t *buffer, uint3
     } else if (agent->pid < 0) {
         BEGET_LOGE("[control_fd] Failed fork service");
     }
+#endif
     return;
 }
 
-static int SendMessage(LoopHandle loop, TaskHandle task, const char *message)
+CONTROL_FD_STATIC int SendMessage(LoopHandle loop, TaskHandle task, const char *message)
 {
     if (message == NULL) {
         BEGET_LOGE("[control_fd] Invalid parameter");
@@ -90,11 +91,15 @@ static int SendMessage(LoopHandle loop, TaskHandle task, const char *message)
     return 0;
 }
 
-static int CmdOnIncommingConnect(const LoopHandle loop, const TaskHandle server)
+CONTROL_FD_STATIC int CmdOnIncommingConnect(const LoopHandle loop, const TaskHandle server)
 {
     TaskHandle client = NULL;
     LE_StreamInfo info = {};
+#ifndef STARTUP_INIT_TEST
     info.baseInfo.flags = TASK_STREAM | TASK_PIPE | TASK_CONNECT;
+#else
+    info.baseInfo.flags = TASK_STREAM | TASK_PIPE | TASK_CONNECT | TASK_TEST;
+#endif
     info.baseInfo.close = OnClose;
     info.baseInfo.userDataSize = sizeof(CmdTask);
     info.disConnectComplete = NULL;

interfaces/innerkits/fd_holder/fd_holder.c

@@ -49,7 +49,7 @@ static int BuildClientSocket(void)
     return sockFd;
 }
 
-static int BuildSendData(char *buffer, size_t size, const char *serviceName, bool hold, bool poll)
+STATIC int BuildSendData(char *buffer, size_t size, const char *serviceName, bool hold, bool poll)
 {
     if (buffer == NULL || size == 0 || serviceName == 0) {
         return -1;

interfaces/innerkits/fd_holder/fd_holder_internal.c

@@ -81,30 +81,8 @@ int BuildControlMessage(struct msghdr *msghdr,  int *fds, int fdCount, bool send
     return 0;
 }
 
-// This function will allocate memory to store FDs
-// Remember to delete when not used anymore.
-int *ReceiveFds(int sock, struct iovec iovec, size_t *outFdCount, bool nonblock, pid_t *requestPid)
+STATIC int *GetFdsFromMsg(size_t *outFdCount, pid_t *requestPid, struct msghdr msghdr)
 {
-    CMSG_BUFFER_TYPE(CMSG_SPACE(sizeof(struct ucred)) +
-         CMSG_SPACE(sizeof(int) * MAX_HOLD_FDS)) control;
-
-    BEGET_ERROR_CHECK(sizeof(control) <= PAGE_SIZE, return NULL, "Too many fds, out of memory");
-
-    struct msghdr msghdr = {
-        .msg_iov = &iovec,
-        .msg_iovlen = 1,
-        .msg_control = &control,
-        .msg_controllen = sizeof(control),
-        .msg_flags = 0,
-    };
-
-    int flags = MSG_CMSG_CLOEXEC | MSG_TRUNC;
-    if (nonblock) {
-        flags |= MSG_DONTWAIT;
-    }
-    ssize_t rc = TEMP_FAILURE_RETRY(recvmsg(sock, &msghdr, flags));
-    BEGET_ERROR_CHECK(rc >= 0, return NULL, "Failed to get fds from remote, err = %d", errno);
-
     if ((msghdr.msg_flags) & MSG_TRUNC) {
         BEGET_LOGE("Message was truncated when receiving fds");
         return NULL;
@@ -115,7 +93,7 @@ int *ReceiveFds(int sock, struct iovec iovec, size_t *outFdCount, bool nonblock,
     size_t fdCount = 0;
     for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg != NULL; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
         if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
-            fds = (int*) CMSG_DATA(cmsg);
+            fds = (int*)CMSG_DATA(cmsg);
             fdCount = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
             BEGET_ERROR_CHECK(fdCount <= MAX_HOLD_FDS, return NULL, "Too many fds returned.");
         }
@@ -139,3 +117,29 @@ int *ReceiveFds(int sock, struct iovec iovec, size_t *outFdCount, bool nonblock,
     *outFdCount = fdCount;
     return outFds;
 }
+
+// This function will allocate memory to store FDs
+// Remember to delete when not used anymore.
+int *ReceiveFds(int sock, struct iovec iovec, size_t *outFdCount, bool nonblock, pid_t *requestPid)
+{
+    CMSG_BUFFER_TYPE(CMSG_SPACE(sizeof(struct ucred)) +
+         CMSG_SPACE(sizeof(int) * MAX_HOLD_FDS)) control;
+
+    BEGET_ERROR_CHECK(sizeof(control) <= PAGE_SIZE, return NULL, "Too many fds, out of memory");
+
+    struct msghdr msghdr = {
+        .msg_iov = &iovec,
+        .msg_iovlen = 1,
+        .msg_control = &control,
+        .msg_controllen = sizeof(control),
+        .msg_flags = 0,
+    };
+
+    int flags = MSG_CMSG_CLOEXEC | MSG_TRUNC;
+    if (nonblock) {
+        flags |= MSG_DONTWAIT;
+    }
+    ssize_t rc = TEMP_FAILURE_RETRY(recvmsg(sock, &msghdr, flags));
+    BEGET_ERROR_CHECK(rc >= 0, return NULL, "Failed to get fds from remote, err = %d", errno);
+    return GetFdsFromMsg(outFdCount, requestPid, msghdr);
+}
\ No newline at end of file

interfaces/innerkits/fs_manager/fstab.c

@@ -542,7 +542,7 @@ static int ParseRequiredMountInfo(const char *item, Fstab *fstab)
         BEGET_ERROR_CHECK(strncpy_s(mountOptions, MAX_BUFFER_LEN -1, p, strlen(p)) == EOK,
             return -1, "Failed to copy required mount info: %s", item);
     }
-    BEGET_LOGV("Mount option of partition %s is [%s]", partName, mountOptions);
+    BEGET_LOGV("Config mount option of partition %s is [%s]", partName, mountOptions);
     if (ParseFstabPerLine(mountOptions, fstab, false, "@") < 0) {
         BEGET_LOGE("Failed to parse mount options of partition \' %s \', options: %s", partName, mountOptions);
         return -1;
@@ -556,7 +556,7 @@ Fstab* LoadFstabFromCommandLine(void)
     char *cmdline = ReadFileData(BOOT_CMD_LINE);
     bool isDone = false;
 
-    BEGET_ERROR_CHECK(cmdline != NULL, return NULL, "Read from \'/proc/cmdline\' failed, err = %d", errno);
+    BEGET_ERROR_CHECK(cmdline != NULL, return NULL, "Read from \'%s\' failed, err = %d", BOOT_CMD_LINE, errno);
     TrimTail(cmdline, '\n');
     BEGET_ERROR_CHECK((fstab = (Fstab *)calloc(1, sizeof(Fstab))) != NULL, return NULL,
         "Allocate memory for FS table failed, err = %d", errno);

interfaces/innerkits/include/beget_ext.h

@@ -28,7 +28,7 @@ extern "C" {
 #define INIT_DEBUG_LEVEL "persist.init.debug.loglevel"
 
 #ifndef INIT_LOG_PATH
-#define INIT_LOG_PATH "/data/init_agent/"
+#define INIT_LOG_PATH STARTUP_INIT_UT_PATH"/data/init_agent/"
 #endif
 
 #if defined(__GNUC__) && (__GNUC__ >= 4)
@@ -49,7 +49,13 @@ typedef enum InitLogLevel {
     INIT_FATAL
 } InitLogLevel;
 
+#if (defined(STARTUP_INIT_TEST) || defined(APPSPAWN_TEST))
+#define FILE_NAME   (strrchr((__FILE__), '/')  + 1)
+#define STATIC
+#else
 #define FILE_NAME   (strrchr((__FILE__), '/') ? strrchr((__FILE__), '/') + 1 : (__FILE__))
+#define STATIC static
+#endif
 
 INIT_PUBLIC_API void StartupLog(InitLogLevel logLevel, uint32_t domain, const char *tag, const char *fmt, ...);
 INIT_PUBLIC_API void SetInitLogLevel(InitLogLevel level);

interfaces/innerkits/service_control/service_control.c

@@ -96,6 +96,7 @@ static int RestartProcess(const char *serviceName, const char *extArgv[], int ex
         BEGET_LOGE("Get service status failed.\n");
         return -1;
     }
+    BEGET_LOGE("Process service %s status: %d ", serviceName, status);
     if (status == SERVICE_STARTED || status == SERVICE_READY) {
         if (StopProcess(serviceName) != 0) {
             BEGET_LOGE("Stop service %s failed", serviceName);
@@ -114,8 +115,6 @@ static int RestartProcess(const char *serviceName, const char *extArgv[], int ex
             BEGET_LOGE("Start service %s failed", serviceName);
             return -1;
         }
-    } else {
-        BEGET_LOGE("Current service status: %d is not support.", status);
     }
     return 0;
 }

services/begetctl/begetctl.h

@@ -46,5 +46,4 @@ int32_t BShellCmdRegister(BShellHandle shell, int execMode);
 }
 #endif
 #endif
-#endif // INIT_UTILS_H
-
+#endif // INIT_UTILS_H
\ No newline at end of file

services/begetctl/bootchart_cmd.c

@@ -21,30 +21,18 @@
 
 static int bootchartCmdEnable(BShellHandle shell, int argc, char **argv)
 {
-    if (argc < 1) {
-        char *helpArgs[] = {"bootchart", NULL};
-        BShellCmdHelp(shell, 1, helpArgs);
-    }
     SystemSetParameter("persist.init.bootchart.enabled", "1");
     return 0;
 }
 
 static int bootchartCmdDisable(BShellHandle shell, int argc, char **argv)
 {
-    if (argc < 1) {
-        char *helpArgs[] = {"bootchart", NULL};
-        BShellCmdHelp(shell, 1, helpArgs);
-    }
     SystemSetParameter("persist.init.bootchart.enabled", "0");
     return 0;
 }
 
 static int bootchartCmdStart(BShellHandle shell, int argc, char **argv)
 {
-    if (argc < 1) {
-        char *helpArgs[] = {"bootchart", NULL};
-        BShellCmdHelp(shell, 1, helpArgs);
-    }
     char enable[4] = {}; // 4 enable size
     uint32_t size = sizeof(enable);
     int ret = SystemGetParameter("persist.init.bootchart.enabled", enable, &size);
@@ -58,13 +46,10 @@ static int bootchartCmdStart(BShellHandle shell, int argc, char **argv)
 
 static int bootchartCmdStop(BShellHandle shell, int argc, char **argv)
 {
-    if (argc < 1) {
-        char *helpArgs[] = {"bootchart", NULL};
-        BShellCmdHelp(shell, 1, helpArgs);
-    }
     SystemSetParameter("ohos.servicectrl.bootchart", "stop");
     return 0;
 }
+
 MODULE_CONSTRUCTOR(void)
 {
     const CmdInfo infos[] = {

services/begetctl/misc_daemon.cpp

@@ -56,10 +56,6 @@ static void ClearLogo(int fd)
 
 static void WriteLogoContent(int fd, const std::string &logoPath, uint32_t size)
 {
-    if (fd < 0 || logoPath.empty() || size == 0) {
-        std::cout << "path is null or size illegal\n";
-        return;
-    }
     FILE *rgbFile = fopen(logoPath.c_str(), "rb");
     if (rgbFile == nullptr) {
         std::cout << "cannot find pic file\n";
@@ -83,20 +79,12 @@ static void WriteLogoContent(int fd, const std::string &logoPath, uint32_t size)
         free(buffer);
         return;
     }
-
-    if (buffer != nullptr) {
-        free(buffer);
-        buffer = nullptr;
-    }
+    free(buffer);
     (void)fclose(rgbFile);
 }
 
 static int WriteLogo(int fd, const std::string &logoPath)
 {
-    if (fd < 0 || logoPath.empty()) {
-        std::cout << "Invalid arguments\n";
-        return -1;
-    }
     int addrOffset = (PARTITION_INFO_POS + PARTITION_INFO_MAX_LENGTH + BLOCK_SZIE_1 - 1) / BLOCK_SZIE_1;
     if (lseek(fd, addrOffset * BLOCK_SZIE_1, SEEK_SET) < 0) {
         BSH_LOGI("Failed lseek logoPath %s errno %d ", logoPath.c_str(), errno);
@@ -108,11 +96,12 @@ static int WriteLogo(int fd, const std::string &logoPath)
         BSH_LOGI("Failed magic logoPath %s errno %d ", logoPath.c_str(), errno);
         return -1;
     }
-
+#ifndef STARTUP_INIT_TEST
     if (magic == LOGO_MAGIC) {
         BSH_LOGI("Get matched magic number, logo already written\n");
         return 0;
     }
+#endif
     struct stat st {};
     magic = LOGO_MAGIC;
     lseek(fd, addrOffset * BLOCK_SZIE_1, SEEK_SET);

services/begetctl/partitionslot.cpp

@@ -29,7 +29,7 @@ static int LoadDevice()
     if (devmgr != nullptr) {
         return devmgr->LoadDevice("partition_slot_service");
     } else {
-        std::cout << "Get devmgr failed" << std::endl;
+        std::cout << "Load devmgr failed" << std::endl;
         return -1;
     }
 }
@@ -39,27 +39,22 @@ static void UnloadDevice()
     auto devmgr = IDeviceManager::Get();
     if (devmgr != nullptr) {
         devmgr->UnloadDevice("partition_slot_service");
-    } else {
-        std::cout << "Get devmgr failed" << std::endl;
     }
 }
 
 static int GetSlot(BShellHandle handle, int32_t argc, char *argv[])
 {
     if (LoadDevice() != 0) {
-        std::cout << "Load partitionslot device failed" << std::endl;
         return -1;
     }
     std::cout << "Command: partitionslot getslot" << std::endl;
     sptr<IPartitionSlot> partitionslot = IPartitionSlot::Get();
     int bootSlots = 0;
     int currentSlot = 0;
-    if (partitionslot == nullptr) {
-        std::cout << "Get partitionslot failed" << std::endl;
-        return -1;
+    if (partitionslot != nullptr) {
+        partitionslot->GetCurrentSlot(currentSlot, bootSlots);
+        std::cout << "The number of slots: " << bootSlots << "," <<  "current slot: " << currentSlot << std::endl;
     }
-    partitionslot->GetCurrentSlot(currentSlot, bootSlots);
-    std::cout << "The number of slots: " << bootSlots << "," <<  "current slot: " << currentSlot << std::endl;
     UnloadDevice();
     return 0;
 }
@@ -71,19 +66,16 @@ static int GetSuffix(BShellHandle handle, int32_t argc, char *argv[])
         return -1;
     }
     if (LoadDevice() != 0) {
-        std::cout << "Load partitionslot device failed" << std::endl;
         return -1;
     }
     std::cout << "Command: partitionslot getsuffix" << std::endl;
     int slot = atoi(argv[1]);
     std::string suffix = "";
     sptr<IPartitionSlot> partitionslot = IPartitionSlot::Get();
-    if (partitionslot == nullptr) {
-        std::cout << "Get partitionslot failed" << std::endl;
-        return -1;
+    if (partitionslot != nullptr) {
+        partitionslot->GetSlotSuffix(slot, suffix);
+        std::cout << "The slot " << slot << " matches with suffix: " << suffix << std::endl;
     }
-    partitionslot->GetSlotSuffix(slot, suffix);
-    std::cout << "The slot " << slot << " matches with suffix: " << suffix << std::endl;
     UnloadDevice();
     return 0;
 }
@@ -95,18 +87,15 @@ static int SetActiveSlot(BShellHandle handle, int32_t argc, char *argv[])
         return -1;
     }
     if (LoadDevice() != 0) {
-        std::cout << "Load partitionslot device failed" << std::endl;
         return -1;
     }
     std::cout << "Command: partitionslot setactive" << std::endl;
     int slot = atoi(argv[1]);
     sptr<IPartitionSlot> partitionslot = IPartitionSlot::Get();
-    if (partitionslot == nullptr) {
-        std::cout << "Get partitionslot failed" << std::endl;
-        return -1;
+    if (partitionslot != nullptr) {
+        partitionslot->SetActiveSlot(slot);
+        std::cout << "Set active slot: " << slot << std::endl;
     }
-    partitionslot->SetActiveSlot(slot);
-    std::cout << "Set active slot: " << slot << std::endl;
     UnloadDevice();
     return 0;
 }
@@ -118,18 +107,15 @@ static int SetUnbootSlot(BShellHandle handle, int32_t argc, char *argv[])
         return -1;
     }
     if (LoadDevice() != 0) {
-        std::cout << "Load partitionslot device failed" << std::endl;
         return -1;
     }
     std::cout << "Command: partitionslot setunboot" << std::endl;
     int slot = atoi(argv[1]);
     sptr<IPartitionSlot> partitionslot = IPartitionSlot::Get();
-    if (partitionslot == nullptr) {
-        std::cout << "Get partitionslot failed" << std::endl;
-        return -1;
+    if (partitionslot != nullptr) {
+        partitionslot->SetSlotUnbootable(slot);
+        std::cout << "Set unboot slot: " << slot << std::endl;
     }
-    partitionslot->SetSlotUnbootable(slot);
-    std::cout << "Set unboot slot: " << slot << std::endl;
     UnloadDevice();
     return 0;
 }

services/begetctl/sandbox.cpp

@@ -47,14 +47,13 @@ static void Usage()
     std::cout << "sandbox -n, --namespace_name=namespace name \"namespace name, system, chipset etc.\"" << std::endl;
     std::cout << "sandbox -p, --process=process name \"sh, hdcd, hdf_devhost, etc.\"" << std::endl;
     std::cout << "sandbox -h, --help \"Show help\"" << std::endl;
+#ifndef STARTUP_INIT_TEST
     exit(0);
+#endif
 }
 
 static void RunSandbox(const std::string &sandboxName)
 {
-    if (sandboxName.empty()) {
-        return;
-    }
     InitDefaultNamespace();
     if (!InitSandboxWithName(sandboxName.c_str())) {
         std::cout << "Init sandbox failed." << std::endl;
@@ -85,10 +84,6 @@ static void EnterShell()
 static const int MAX_PROCESS_ARGC = 8;
 static void EnterExec(const std::string &processName)
 {
-    if (processName.empty()) {
-        std::cout << "process name is nullptr." << std::endl;
-        return;
-    }
     std::string tmpName = processName;
     std::vector<std::string> vtr;
     const std::string sep = " ";

services/begetctl/service_control.c

@@ -47,8 +47,9 @@ static int main_cmd(BShellHandle shell, int argc, char **argv)
     } else if (strcmp(argv[0], "stop") == 0) {
         ServiceControlWithExtra(argv[1], 1, (const char **)argv + SERVICE_START_NUMBER, argc - SERVICE_START_NUMBER);
     } else if (strcmp(argv[0], "timer_start") == 0) {
-        if (argc < SERVICE_START_NUMBER) {
-            return -1;
+        if (argc <= SERVICE_START_NUMBER) {
+            ServiceControlUsage(shell, argc, argv);
+            return 0;
         }
         char *timeBuffer = argv[SERVICE_START_NUMBER];
         errno = 0;

services/init/adapter/init_adapter.c

@@ -17,7 +17,6 @@
 #include <errno.h>
 #include <semaphore.h>
 #include <sys/prctl.h>
-#include <sys/reboot.h>
 #include <unistd.h>
 #if defined OHOS_LITE && !defined __LINUX__
 #include <sys/capability.h>
@@ -30,14 +29,6 @@
 #endif
 #include "init_log.h"
 
-void RebootSystem(void)
-{
-    int ret = reboot(RB_AUTOBOOT);
-    if (ret != 0) {
-        INIT_LOGE("reboot failed! syscall ret %d, err %d.", ret, errno);
-    }
-}
-
 int KeepCapability(void)
 {
 #if ((defined __LINUX__) || (!defined OHOS_LITE))

services/init/include/init.h

@@ -34,6 +34,12 @@ extern "C" {
 
 #define UNUSED(x) (void)(x)
 
+#ifndef STARTUP_INIT_TEST
+#define INIT_STATIC static
+#else
+#define INIT_STATIC
+#endif
+
 void SystemInit(void);
 void LogInit(void);
 void SystemPrepare(void);

services/init/include/init_adapter.h

@@ -40,7 +40,6 @@ extern "C" {
 #endif
 #endif
 
-void RebootSystem(void);
 int KeepCapability(void);
 int SetAmbientCapability(int cap);
 void ExecuteRcs(void);

services/init/init_common_cmds.c

@@ -117,6 +117,9 @@ const struct CmdArgs *GetCmdArg(const char *cmdContent, const char *delim, int a
         while (isspace(*p)) {
             p++;
         }
+        if (end == p) { // empty cmd content
+            break;
+        }
         token = strstr(p, delim);
         if (token == NULL) {
             ctx->argv[ctx->argc] = AddOneArg(p, end - p);
@@ -151,7 +154,7 @@ void FreeCmdArg(struct CmdArgs *cmd)
 
 void ExecCmd(const struct CmdTable *cmd, const char *cmdContent)
 {
-    INIT_ERROR_CHECK(cmd != NULL, return, "Invalid cmd for %s", cmdContent);
+    INIT_ERROR_CHECK(cmd != NULL, return, "Invalid cmd.");
     const struct CmdArgs *ctx = GetCmdArg(cmdContent, " ", cmd->maxArg);
     if (ctx == NULL) {
         INIT_LOGE("Invalid arguments cmd: %s content: %s", cmd->name, cmdContent);
@@ -358,10 +361,7 @@ static void DoMkDir(const struct CmdArgs *ctx)
         INIT_LOGE("Failed to change owner %s, err %d.", ctx->argv[0], errno);
     }
     ret = SetFileCryptPolicy(ctx->argv[0]);
-    if (ret != 0) {
-        INIT_LOGW("Failed to set file fscrypt");
-    }
-
+    INIT_CHECK_ONLY_ELOG(ret == 0, "Failed to set file fscrypt");
     return;
 }
 
@@ -578,7 +578,7 @@ static const struct CmdTable g_cmdTable[] = {
     { "stop ", 1, 1, DoStop },
     { "reset ", 1, 1, DoReset },
     { "copy ", 2, 2, DoCopy },
-    { "reboot ", 1, 1, DoRebootCmd },
+    { "reboot ", 0, 1, DoRebootCmd },
     { "setrlimit ", 3, 3, DoSetrlimit },
     { "sleep ", 1, 1, DoSleep },
     { "wait ", 1, 2, DoWait },

services/init/init_common_service.c

@@ -181,11 +181,7 @@ static int SetPerms(const Service *service)
 
 static int WritePid(const Service *service)
 {
-    const int maxPidStrLen = 50;
-    char pidString[maxPidStrLen];
     pid_t childPid = getpid();
-    int len = snprintf_s(pidString, maxPidStrLen, maxPidStrLen - 1, "%d", childPid);
-    INIT_ERROR_CHECK(len > 0, return SERVICE_FAILURE, "Failed to format pid for service %s", service->name);
     for (int i = 0; i < service->writePidArgs.count; i++) {
         if (service->writePidArgs.argv[i] == NULL) {
             continue;
@@ -198,16 +194,16 @@ static int WritePid(const Service *service)
             fd = fopen(service->writePidArgs.argv[i], "wb");
         }
         if (fd != NULL) {
-            INIT_CHECK_ONLY_ELOG((int)fwrite(pidString, 1, len, fd) == len,
-                "Failed to write %s pid:%s", service->writePidArgs.argv[i], pidString);
+            INIT_CHECK_ONLY_ELOG((int)fprintf(fd, "%d", childPid) > 0,
+                "Failed to write %s pid:%d", service->writePidArgs.argv[i], childPid);
             (void)fclose(fd);
         } else {
-            INIT_LOGE("Failed to open %s.", service->writePidArgs.argv[i]);
+            INIT_LOGE("Failed to open realPath: %s  %s errno:%d.", realPath, service->writePidArgs.argv[i], errno);
         }
         if (realPath != NULL) {
             free(realPath);
         }
-        INIT_LOGV("ServiceStart writepid filename=%s, childPid=%s, ok", service->writePidArgs.argv[i], pidString);
+        INIT_LOGV("ServiceStart writepid filename=%s, childPid=%d, ok", service->writePidArgs.argv[i], childPid);
     }
     return SERVICE_SUCCESS;
 }

services/init/init_group_manager.c

@@ -251,7 +251,6 @@ InitGroupNode *GetGroupNode(int type, const char *name)
     if (type >= NODE_TYPE_GROUPS) {
         return NULL;
     }
-    INIT_LOGV("GetGroupNode type %d %p name %s", type, g_initWorkspace.hashMap[type], name);
     HashNode *node = OH_HashMapGet(g_initWorkspace.hashMap[type], name);
     if (node == NULL) {
         return NULL;

services/init/lite/init_signal_handler.c

@@ -12,12 +12,24 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <errno.h>
 #include <signal.h>
+#include <sys/reboot.h>
 #include <sys/wait.h>
 
-#include "init_adapter.h"
+#include "init_log.h"
 #include "init_service_manager.h"
 
+static void RebootSystem(void)
+{
+#ifndef STARTUP_INIT_TEST
+    int ret = reboot(RB_AUTOBOOT);
+    if (ret != 0) {
+        INIT_LOGE("reboot failed! syscall ret %d, err %d.", ret, errno);
+    }
+#endif
+}
+
 void ReapService(Service *service)
 {
     if (service == NULL) {

services/init/standard/fd_holder_service.c

@@ -34,11 +34,6 @@ static void FreeFds(int *fds)
 
 static int HandlerHoldFds(Service *service, int *fds, size_t fdCount, const char *pollStr)
 {
-    if (service == NULL) {
-        INIT_LOGE("Request hold fds with invalid service");
-        return -1;
-    }
-
     if (fds == NULL || fdCount == 0 || fdCount > MAX_HOLD_FDS) {
         INIT_LOGE("Service %s request hold fds with invalid fds", service->name);
         return -1;
@@ -93,64 +88,6 @@ static void SendErrorInfo(int sock, const char *errInfo, const char *serviceName
     }
 }
 
-static void SendFdsInfo(int sock, Service *service)
-{
-    // Sanity check
-    if (sock < 0 || service == NULL) {
-        INIT_LOGE("Try to send fd with invalid parameter");
-        return;
-    }
-    char sendBuffer[MAX_FD_HOLDER_BUFFER] = {};
-    if (strncpy_s(sendBuffer, MAX_FD_HOLDER_BUFFER, "send done", strlen("send done")) != 0) {
-        INIT_LOGE("Failed to copy, err = %d", errno);
-        return;
-    }
-    struct iovec iovec = {
-        .iov_base = sendBuffer,
-        .iov_len = strlen(sendBuffer),
-    };
-
-    struct msghdr msghdr = {
-        .msg_iov = &iovec,
-        .msg_iovlen = 1,
-    };
-
-    if (BuildControlMessage(&msghdr, service->fds, service->fdCount, false) < 0) {
-        SendErrorInfo(sock, "Failed to build send message", service->name);
-    } else {
-        if (TEMP_FAILURE_RETRY(sendmsg(sock, &msghdr, MSG_NOSIGNAL)) < 0) {
-            INIT_LOGE("Failed to send fd info to service \' %s \', err = %d", service->name, errno);
-        } else {
-            // Send fd to service OK, need to close fds in init.
-            CloseServiceFds(service, true);
-        }
-    }
-
-    if (msghdr.msg_control != NULL) {
-        free(msghdr.msg_control);
-        msghdr.msg_control = NULL;
-        msghdr.msg_controllen = 0;
-    }
-}
-
-static void HandlerGetFds(int sock, Service *service)
-{
-    if (sock < 0 || service == NULL) {
-        INIT_LOGE("Get fd from init with 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);
-        SendErrorInfo(sock, "Service without any fds", service->name);
-        return;
-    }
-
-    // Send fds back to service
-    SendFdsInfo(sock, service);
-}
-
 static int CheckFdHolderPermission(Service *service, pid_t requestPid)
 {
     if (service == NULL) {
@@ -202,6 +139,7 @@ static void HandlerFdHolder(int sock)
 
     Service *service = GetServiceByName(serviceName);
     if (CheckFdHolderPermission(service, requestPid) < 0) {
+        SendErrorInfo(sock, "Invalid service", serviceName);
         // Permission check failed.
         // But fds may already dup to init, so close them.
         CloseFds(fds, fdCount);
@@ -214,10 +152,6 @@ static void HandlerFdHolder(int sock)
         if (HandlerHoldFds(service, fds, fdCount, pollStr) < 0) {
             CloseFds(fds, fdCount);
         }
-    } else if (strcmp(action, ACTION_GET) == 0) {
-        // In this case, ignore fds, just close them if fd passed to init
-        CloseFds(fds, fdCount);
-        HandlerGetFds(sock, service);
     } else {
         INIT_LOGE("Unexpected action: %s", action);
         CloseFds(fds, fdCount);
@@ -226,7 +160,7 @@ static void HandlerFdHolder(int sock)
     FreeStringVector(msg, msgCount);
 }
 
-static void ProcessFdHoldEvent(const WatcherHandle taskHandle, int fd, uint32_t *events, const void *context)
+void ProcessFdHoldEvent(const WatcherHandle taskHandle, int fd, uint32_t *events, const void *context)
 {
     HandlerFdHolder(fd);
     *events = Event_Read;

services/init/standard/init.c

@@ -189,8 +189,10 @@ static void StartInitSecondStage(void)
             // Just abort
             INIT_LOGE("Mount required partitions failed; please check fstab file");
             // Execute sh for debugging
+#ifndef STARTUP_INIT_TEST
             execv("/bin/sh", NULL);
             abort();
+#endif
         }
     }
 
@@ -258,7 +260,7 @@ static void RecordInitBootEvent(const char *initBootEvent)
     return;
 }
 
-static void BootStateChange(int start, const char *content)
+INIT_STATIC void BootStateChange(int start, const char *content)
 {
     if (start == 0) {
         clock_gettime(CLOCK_MONOTONIC, &(g_bootJob.startTime));
@@ -291,13 +293,13 @@ static void InitLoadParamFiles(void)
     FreeCfgFiles(files);
 }
 
-static void InitPreHook(const HOOK_INFO *hookInfo, void *executionContext)
+INIT_STATIC void InitPreHook(const HOOK_INFO *hookInfo, void *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)
+INIT_STATIC void InitPostHook(const HOOK_INFO *hookInfo, void *executionContext, int executionRetVal)
 {
     INIT_TIMING_STAT *stat = (INIT_TIMING_STAT *)executionContext;
     clock_gettime(CLOCK_MONOTONIC, &(stat->endTime));
@@ -322,7 +324,7 @@ static void InitSysAdj(void)
     return;
 }
 
-static void TriggerServices(int startMode)
+INIT_STATIC void TriggerServices(int startMode)
 {
     int index = 0;
     int jobNum = 0;
@@ -371,7 +373,7 @@ static void TriggerServices(int startMode)
 void SystemConfig(void)
 {
     INIT_TIMING_STAT timingStat;
-    
+
     InitSysAdj();
     HOOK_EXEC_OPTIONS options;
 

services/init/standard/init_cmds.c

@@ -45,6 +45,8 @@
 #include "fscrypt_utils.h"
 
 #define FSCRYPT_POLICY_BUF_SIZE (60)
+#define DECIMAL 10
+#define OCTAL 8
 
 int GetParamValue(const char *symValue, unsigned int symLen, char *paramValue, unsigned int paramLen)
 {
@@ -91,7 +93,6 @@ 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]);
     pid_t pid = fork();
     INIT_ERROR_CHECK(!(pid < 0), return, "Fork new process to format failed: %d", errno);
@@ -250,16 +251,14 @@ static void DoMakeNode(const struct CmdArgs *ctx)
     const int authorityPos = 2;
     const int majorDevicePos = 3;
     const int minorDevicePos = 4;
-    const int decimal = 10;
-    const int octal = 8;
     INIT_ERROR_CHECK(access(ctx->argv[1], F_OK), return, "DoMakeNode failed, path has sexisted");
     mode_t deviceMode = GetDeviceMode(ctx->argv[deviceTypePos]);
     errno = 0;
-    unsigned int major = strtoul(ctx->argv[majorDevicePos], NULL, decimal);
+    unsigned int major = strtoul(ctx->argv[majorDevicePos], NULL, DECIMAL);
     INIT_CHECK_ONLY_ELOG(errno != ERANGE, "Failed to strtoul %s", ctx->argv[majorDevicePos]);
-    unsigned int minor = strtoul(ctx->argv[minorDevicePos], NULL, decimal);
+    unsigned int minor = strtoul(ctx->argv[minorDevicePos], NULL, DECIMAL);
     INIT_CHECK_ONLY_ELOG(errno != ERANGE, "Failed to strtoul %s", ctx->argv[minorDevicePos]);
-    mode_t authority = strtoul(ctx->argv[authorityPos], NULL, octal);
+    mode_t authority = strtoul(ctx->argv[authorityPos], NULL, OCTAL);
     INIT_CHECK_ONLY_ELOG(errno != ERANGE, "Failed to strtoul %s", ctx->argv[authorityPos]);
     int ret = mknod(ctx->argv[0], deviceMode | authority, makedev(major, minor));
     if (ret != 0) {
@@ -270,11 +269,10 @@ static void DoMakeNode(const struct CmdArgs *ctx)
 static void DoMakeDevice(const struct CmdArgs *ctx)
 {
     // format: makedev major minor
-    const int decimal = 10;
     errno = 0;
-    unsigned int major = strtoul(ctx->argv[0], NULL, decimal);
+    unsigned int major = strtoul(ctx->argv[0], NULL, DECIMAL);
     INIT_CHECK_ONLY_ELOG(errno != ERANGE, "Failed to strtoul %s", ctx->argv[0]);
-    unsigned int minor = strtoul(ctx->argv[1], NULL, decimal);
+    unsigned int minor = strtoul(ctx->argv[1], NULL, DECIMAL);
     INIT_CHECK_ONLY_ELOG(errno != ERANGE, "Failed to strtoul %s", ctx->argv[1]);
     dev_t deviceId = makedev(major, minor);
     INIT_CHECK_ONLY_ELOG(deviceId >= 0, "DoMakedevice \" major:%s, minor:%s \" failed :%d ", ctx->argv[0],
@@ -302,10 +300,6 @@ static void DoUmountFstabFile(const struct CmdArgs *ctx)
 
 static void DoRestorecon(const struct CmdArgs *ctx)
 {
-    if (ctx->argc != 1) {
-        INIT_LOGE("DoRestorecon invalid arguments.");
-        return;
-    }
     PluginExecCmdByName("restoreContentRecurse", ctx->argv[0]);
     return;
 }
@@ -411,11 +405,10 @@ static void DoTimerStop(const struct CmdArgs *ctx)
 static bool InitFscryptPolicy(void)
 {
     char policy[FSCRYPT_POLICY_BUF_SIZE];
-    if (LoadFscryptPolicy(policy, FSCRYPT_POLICY_BUF_SIZE) != 0) {
-        return false;
-    }
-    if (SetFscryptSysparam(policy) == 0) {
-        return true;
+    if (LoadFscryptPolicy(policy, FSCRYPT_POLICY_BUF_SIZE) == 0) {
+        if (SetFscryptSysparam(policy) == 0) {
+            return true;
+        }
     }
     return false;
 }
@@ -423,10 +416,6 @@ 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("Parameter is invalid");
-        return;
-    }
     const char *dataDir = "/data";
     if (strncmp(ctx->argv[0], dataDir, strlen(dataDir)) != 0) {
         INIT_LOGE("Not data partitation");
@@ -449,11 +438,6 @@ static void DoInitGlobalKey(const struct CmdArgs *ctx)
 
 static void DoInitMainUser(const struct CmdArgs *ctx)
 {
-    if (ctx == NULL) {
-        INIT_LOGE("Do init main user: para invalid");
-        return;
-    }
-
     char * const argv[] = {
         "/system/bin/sdc",
         "filecrypt",
@@ -466,10 +450,6 @@ static void DoInitMainUser(const struct CmdArgs *ctx)
 
 static void DoMkswap(const struct CmdArgs *ctx)
 {
-    if (ctx == NULL) {
-        INIT_LOGE("Parameter is invalid");
-        return;
-    }
     char *const argv[] = {
         "/system/bin/mkswap",
         ctx->argv[0],
@@ -481,10 +461,6 @@ static void DoMkswap(const struct CmdArgs *ctx)
 
 static void DoSwapon(const struct CmdArgs *ctx)
 {
-    if (ctx == NULL) {
-        INIT_LOGE("Parameter is invalid");
-        return;
-    }
     char *const argv[] = {
         "/system/bin/swapon",
         ctx->argv[0],
@@ -497,16 +473,7 @@ static void DoSwapon(const struct CmdArgs *ctx)
 static void DoMkSandbox(const struct CmdArgs *ctx)
 {
     INIT_LOGV("Do make sandbox start");
-    if ((ctx == NULL) || (ctx->argc != 1)) {
-        INIT_LOGE("Call DoMkSandbox with invalid arguments");
-        return;
-    }
-
     const char *sandbox = ctx->argv[0];
-    if (sandbox == NULL) {
-        INIT_LOGE("Invalid sandbox name.");
-        return;
-    }
     InitDefaultNamespace();
     if (!InitSandboxWithName(sandbox)) {
         INIT_LOGE("Failed to init sandbox with name %s.", sandbox);
@@ -525,15 +492,15 @@ static void DoMkSandbox(const struct CmdArgs *ctx)
 static const struct CmdTable g_cmdTable[] = {
     { "syncexec ", 1, 10, DoSyncExec },
     { "exec ", 1, 10, DoExec },
-    { "mknode ", 1, 5, DoMakeNode },
+    { "mknode ", 5, 5, DoMakeNode },
     { "makedev ", 2, 2, DoMakeDevice },
     { "symlink ", 2, 2, DoSymlink },
-    { "trigger ", 1, 1, DoTriggerCmd },
+    { "trigger ", 0, 1, DoTriggerCmd },
     { "insmod ", 1, 10, DoInsmod },
     { "setparam ", 2, 2, DoSetParam },
-    { "load_persist_params ", 1, 1, DoLoadPersistParams },
+    { "load_persist_params ", 0, 1, DoLoadPersistParams },
     { "load_param ", 1, 2, DoLoadDefaultParams },
-    { "load_access_token_id ", 1, 1, DoLoadAccessTokenId },
+    { "load_access_token_id ", 0, 1, DoLoadAccessTokenId },
     { "ifup ", 1, 1, DoIfup },
     { "mount_fstab ", 1, 1, DoMountFstabFile },
     { "umount_fstab ", 1, 1, DoUmountFstabFile },

services/init/standard/init_mount.c

@@ -38,11 +38,9 @@ Fstab* LoadRequiredFstab(void)
     fstab = LoadFstabFromCommandLine();
     if (fstab == NULL) {
         INIT_LOGI("Cannot load fstab from command line, try read from fstab.required");
-        const char *fstabFile = "/etc/fstab.required";
+        const char *fstabFile = STARTUP_INIT_UT_PATH"/etc/fstab.required";
         INIT_CHECK(access(fstabFile, F_OK) == 0, fstabFile = "/system/etc/fstab.required");
-#ifndef STARTUP_INIT_TEST
         INIT_ERROR_CHECK(access(fstabFile, F_OK) == 0, abort(), "Failed get fstab.required");
-#endif
         fstab = ReadFstabFromFile(fstabFile, false);
     }
     return fstab;

services/init/standard/init_service.c

@@ -83,13 +83,12 @@ int ServiceExec(const Service *service)
             "setpriority failed for %s, importance = %d, err=%d", service->name, service->importance, errno);
     }
     OpenHidebug(service->name);
-    // L2 Can not be reset env
     if (service->extraArgs.argv != NULL && service->extraArgs.count > 0) {
         INIT_CHECK_ONLY_ELOG(execv(service->extraArgs.argv[0], service->extraArgs.argv) == 0,
-            "service %s execve failed! err %d.", service->name, errno);
+            "service %s execv failed! err %d.", service->name, errno);
     } else {
         INIT_CHECK_ONLY_ELOG(execv(service->pathArgs.argv[0], service->pathArgs.argv) == 0,
-            "service %s execve failed! err %d.", service->name, errno);
+            "service %s execv failed! err %d.", service->name, errno);
     }
     return SERVICE_SUCCESS;
 }

services/init/standard/init_signal_handler.c

@@ -16,15 +16,16 @@
 #include <sys/wait.h>
 
 #include "control_fd.h"
+#include "init.h"
 #include "init_adapter.h"
 #include "init_log.h"
 #include "init_param.h"
 #include "init_service_manager.h"
 #include "loop_event.h"
 
-SignalHandle g_sigHandle = NULL;
+static SignalHandle g_sigHandle = NULL;
 
-static void ProcessSignal(const struct signalfd_siginfo *siginfo)
+INIT_STATIC void ProcessSignal(const struct signalfd_siginfo *siginfo)
 {
     switch (siginfo->ssi_signo) {
         case SIGCHLD: {
@@ -38,7 +39,7 @@ static void ProcessSignal(const struct signalfd_siginfo *siginfo)
                 Service* service = GetServiceByPid(sigPID);
                 // check child process exit status
                 if (WIFSIGNALED(procStat)) {
-                    INIT_LOGE("Child process %s(pid %d) exit with signal : %d",
+                    INIT_LOGE("Child process %s(pid %d) exit with code : %d",
                         service == NULL ? "Unknown" : service->name, sigPID, WTERMSIG(procStat));
                 }
                 if (WIFEXITED(procStat)) {
@@ -69,14 +70,12 @@ static void ProcessSignal(const struct signalfd_siginfo *siginfo)
 
 void SignalInit(void)
 {
-    if (LE_CreateSignalTask(LE_GetDefaultLoop(), &g_sigHandle, ProcessSignal) != 0) {
-        INIT_LOGW("initialize signal handler failed");
-        return;
-    }
-    if (LE_AddSignal(LE_GetDefaultLoop(), g_sigHandle, SIGCHLD) != 0) {
-        INIT_LOGW("start SIGCHLD handler failed");
-    }
-    if (LE_AddSignal(LE_GetDefaultLoop(), g_sigHandle, SIGTERM) != 0) {
-        INIT_LOGW("start SIGTERM handler failed");
+    if (LE_CreateSignalTask(LE_GetDefaultLoop(), &g_sigHandle, ProcessSignal) == 0) {
+        if (LE_AddSignal(LE_GetDefaultLoop(), g_sigHandle, SIGCHLD) != 0) {
+            INIT_LOGW("start SIGCHLD handler failed");
+        }
+        if (LE_AddSignal(LE_GetDefaultLoop(), g_sigHandle, SIGTERM) != 0) {
+            INIT_LOGW("start SIGTERM handler failed");
+        }
     }
 }

services/log/init_log.c

@@ -150,20 +150,18 @@ INIT_LOCAL_API void EnableInitLogFromCmdline(void)
 {
     SetInitCommLog(InitLog);
     char level[MAX_BUFFER_LEN] = {0};
-    char *buffer = ReadFileData("/proc/cmdline");
+    char *buffer = ReadFileData(BOOT_CMD_LINE);
     if (buffer == NULL) {
         INIT_LOGE("Failed to read \"/proc/cmdline\"");
         return;
     }
     int ret = GetProcCmdlineValue("initloglevel", buffer, level, MAX_BUFFER_LEN);
     free(buffer);
-    if (ret != 0) {
-        INIT_LOGE("Failed get log level from cmdline");
-        return;
+    if (ret == 0) {
+        errno = 0;
+        unsigned int logLevel = (unsigned int)strtoul(level, 0, 10); // 10 is decimal
+        INIT_INFO_CHECK(errno == 0, return, "Failed strtoul %s, err=%d", level, errno);
+        SetInitLogLevel((InitLogLevel)logLevel);
     }
-    errno = 0;
-    unsigned int logLevel = (unsigned int)strtoul(level, 0, 10); // 10 is decimal
-    INIT_INFO_CHECK(errno == 0, return, "Failed strtoul %s, err=%d", level, errno);
-    SetInitLogLevel((InitLogLevel)logLevel);
     return;
 }

services/loopevent/loop/le_epoll.c

@@ -13,12 +13,14 @@
  * limitations under the License.
  */
 
+#include <errno.h>
+
 #include "le_epoll.h"
 #include "le_utils.h"
 
 static int IsValid_(const EventEpoll *loop)
 {
-    return loop->epollFd > 0;
+    return loop->epollFd >= 0;
 }
 
 static void GetEpollEvent_(int fd, int op, struct epoll_event *event)
@@ -36,6 +38,7 @@ static LE_STATUS Close_(const EventLoop *loop)
 {
     LE_CHECK(loop != NULL, return LE_FAILURE, "Invalid loop");
     EventEpoll *epoll = (EventEpoll *)loop;
+    LE_LOGV("Close_ epollFd %d", epoll->epollFd);
     close(epoll->epollFd);
     free(epoll);
     return LE_SUCCESS;
@@ -124,7 +127,7 @@ LE_STATUS CreateEpollLoop(EventLoop **loop, uint32_t maxevents, uint32_t timeout
     EventEpoll *epoll = (EventEpoll *)malloc(sizeof(EventEpoll) + sizeof(struct epoll_event) * (maxevents));
     LE_CHECK(epoll != NULL, return LE_FAILURE, "Failed to alloc memory for epoll");
     epoll->epollFd = epoll_create(maxevents);
-    LE_CHECK(epoll->epollFd > 0, free(epoll);
+    LE_CHECK(epoll->epollFd >= 0, free(epoll);
         return LE_FAILURE, "Failed to create epoll");
 
     *loop = (EventLoop *)epoll;

services/loopevent/loop/le_loop.c

@@ -137,11 +137,11 @@ LoopHandle LE_GetDefaultLoop(void)
     return (LoopHandle)g_defaultLoop;
 }
 
-LE_STATUS LE_CreateLoop(LoopHandle *handlle)
+LE_STATUS LE_CreateLoop(LoopHandle *handle)
 {
     EventLoop *loop = NULL;
     LE_STATUS ret = CreateLoop_(&loop, LOOP_MAX_SOCKET, DEFAULT_TIMEOUT);
-    *handlle = (LoopHandle)loop;
+    *handle = (LoopHandle)loop;
     return ret;
 }
 
@@ -156,6 +156,9 @@ void LE_CloseLoop(const LoopHandle loopHandle)
 {
     LE_CHECK(loopHandle != NULL, return, "Invalid handle");
     CloseLoop((EventLoop *)loopHandle);
+    if ((LoopHandle)g_defaultLoop == loopHandle) {
+        g_defaultLoop = NULL;
+    }
 }
 
 void LE_StopLoop(const LoopHandle handle)

services/loopevent/socket/le_socket.c

@@ -90,6 +90,7 @@ static LE_STATUS GetSockaddrFromServer_(const char *server, struct sockaddr_in *
     addr->sin_port = htons(port);
     ret = inet_pton(AF_INET, server, &addr->sin_addr);
     LE_CHECK(ret >= 0, return LE_FAILURE, "Failed to inet_pton addr %s", server);
+    LE_LOGV("CreateTcpSocket server: %s port: %d", server, port);
     return LE_SUCCESS;
 }
 
@@ -119,10 +120,9 @@ static int CreateTcpSocket_(const char *server)
 
     struct sockaddr_in serverAddr;
     GetSockaddrFromServer_(server, &serverAddr);
-    LE_LOGV("CreateTcpSocket connect: %s ", server);
     int ret = connect(fd, (struct sockaddr *)&serverAddr, sizeof(serverAddr));
     LE_CHECK(ret >= 0, close(fd);
-        return ret, "Failed to connect socket");
+        return ret, "Failed to connect socket errno:%d", errno);
     return fd;
 }
 

services/loopevent/task/le_task.c

@@ -38,7 +38,7 @@ BaseTask *CreateTask(const LoopHandle loopHandle, int fd, const LE_BaseInfo *inf
     if ((size >= LOOP_MAX_BUFFER) || ((size + info->userDataSize) >= LOOP_MAX_BUFFER)) {
         return NULL;
     }
-    BaseTask *task = (BaseTask *)malloc(size + info->userDataSize);
+    BaseTask *task = (BaseTask *)calloc(1, size + info->userDataSize);
     LE_CHECK(task != NULL, return NULL, "Failed to alloc for task");
     HASHMAPInitNode(&task->hashNode);
     // key id

services/loopevent/utils/le_utils.c

@@ -22,11 +22,7 @@ void SetNoBlock(int fd)
     if (option < 0) {
         return;
     }
-
     option = option | O_NONBLOCK | FD_CLOEXEC;
-    option = fcntl(fd, F_SETFD, option);
-    if (option < 0) {
-        return;
-    }
+    (void)fcntl(fd, F_SETFD, option);
     return;
 }
\ No newline at end of file

services/modules/bootchart/bootchart.c

@@ -33,7 +33,7 @@
 
 static BootchartCtrl *g_bootchartCtrl = NULL;
 
-static long long GetJiffies(void)
+BOOTCHART_STATIC long long GetJiffies(void)
 {
     struct timespec time1 = {0};
     clock_gettime(CLOCK_MONOTONIC, &time1);
@@ -63,7 +63,7 @@ char *ReadFileToBuffer(const char *fileName, char *buffer, uint32_t bufferSize)
     return (readLen > 0) ? buffer : NULL;
 }
 
-static void BootchartLogHeader(void)
+BOOTCHART_STATIC void BootchartLogHeader(void)
 {
     char date[32]; // 32 data size
     time_t tm = time(NULL);
@@ -97,7 +97,7 @@ static void BootchartLogHeader(void)
     (void)fclose(file);
 }
 
-static void BootchartLogFile(FILE *log, const char *procfile)
+BOOTCHART_STATIC void BootchartLogFile(FILE *log, const char *procfile)
 {
     (void)fprintf(log, "%lld\n", GetJiffies());
     char *data = ReadFileToBuffer(procfile, g_bootchartCtrl->buffer, g_bootchartCtrl->bufferSize);
@@ -106,7 +106,7 @@ static void BootchartLogFile(FILE *log, const char *procfile)
     }
 }
 
-static void BootchartLogProcessStat(FILE *log, pid_t pid)
+BOOTCHART_STATIC void BootchartLogProcessStat(FILE *log, pid_t pid)
 {
     static char path[255] = { }; // 255 path length
     static char nameBuffer[255] = { }; // 255 path length
@@ -143,7 +143,7 @@ static void BootchartLogProcessStat(FILE *log, pid_t pid)
     }
 }
 
-static void bootchartLogProcess(FILE *log)
+BOOTCHART_STATIC void bootchartLogProcess(FILE *log)
 {
     (void)fprintf(log, "%lld\n", GetJiffies());
     DIR *pDir = opendir("/proc");
@@ -160,7 +160,7 @@ static void bootchartLogProcess(FILE *log)
     (void)fputc('\n', log);
 }
 
-static void *BootchartThreadMain(void *data)
+BOOTCHART_STATIC void *BootchartThreadMain(void *data)
 {
     PLUGIN_LOGI("bootcharting start");
     FILE *statFile = fopen(BOOTCHART_OUTPUT_PATH"proc_stat.log", "w");
@@ -210,7 +210,7 @@ static void *BootchartThreadMain(void *data)
     return NULL;
 }
 
-static void BootchartDestory(void)
+BOOTCHART_STATIC void BootchartDestory(void)
 {
     pthread_mutex_destroy(&(g_bootchartCtrl->mutex));
     pthread_cond_destroy(&(g_bootchartCtrl->cond));
@@ -218,7 +218,7 @@ static void BootchartDestory(void)
     g_bootchartCtrl = NULL;
 }
 
-static int DoBootchartStart(void)
+BOOTCHART_STATIC int DoBootchartStart(void)
 {
     if (g_bootchartCtrl != NULL) {
         PLUGIN_LOGI("bootcharting has been start");
@@ -247,7 +247,7 @@ static int DoBootchartStart(void)
     return 0;
 }
 
-static int DoBootchartStop(void)
+BOOTCHART_STATIC int DoBootchartStop(void)
 {
     if (g_bootchartCtrl == NULL || !g_bootchartCtrl->start) {
         PLUGIN_LOGI("bootcharting not start");
@@ -263,7 +263,7 @@ static int DoBootchartStop(void)
     return 0;
 }
 
-static int DoBootchartCmd(int id, const char *name, int argc, const char **argv)
+BOOTCHART_STATIC int DoBootchartCmd(int id, const char *name, int argc, const char **argv)
 {
     PLUGIN_LOGI("DoBootchartCmd argc %d %s", argc, name);
     PLUGIN_CHECK(argc >= 1, return -1, "Invalid parameter");
@@ -276,7 +276,7 @@ static int DoBootchartCmd(int id, const char *name, int argc, const char **argv)
 }
 
 static int32_t g_executorId = -1;
-static int BootchartInit(void)
+BOOTCHART_STATIC int BootchartInit(void)
 {
     if (g_executorId == -1) {
         g_executorId = AddCmdExecutor("bootchart", DoBootchartCmd);
@@ -285,7 +285,7 @@ static int BootchartInit(void)
     return 0;
 }
 
-static void BootchartExit(void)
+BOOTCHART_STATIC void BootchartExit(void)
 {
     PLUGIN_LOGI("BootchartExit executorId %d", g_executorId);
     if (g_executorId != -1) {

services/modules/bootchart/bootchart.h

@@ -29,4 +29,10 @@ typedef struct {
     char buffer[DEFAULT_BUFFER];
 } BootchartCtrl;
 
+#ifdef STARTUP_INIT_TEST
+#define BOOTCHART_STATIC
+#else
+#define BOOTCHART_STATIC static
+#endif
+
 #endif /* _PLUGIN_BOOTCHART_H */

services/modules/bootevent/bootevent.c

@@ -254,8 +254,9 @@ static void BootEventParaFireByName(const char *paramName)
     const char *clearBootEventArgv[] = {"bootevent"};
     // clear servie extra data
     PluginExecCmd("clear", ARRAY_LENGTH(clearBootEventArgv), clearBootEventArgv);
-
+#ifndef STARTUP_INIT_TEST
     HookMgrExecute(GetBootStageHookMgr(), INIT_BOOT_COMPLETE, NULL, NULL);
+#endif
     return;
 }
 
@@ -304,7 +305,7 @@ static void AddCmdBootEvent(int argc, const char **argv)
     if (argc < 4) { // 4 is min args cmd boot event required
         return;
     }
-    
+
     BOOT_EVENT_PARAM_ITEM *item = calloc(1, sizeof(BOOT_EVENT_PARAM_ITEM));
     if (item == NULL) {
         return;
@@ -431,7 +432,7 @@ MODULE_CONSTRUCTOR(void)
     HookMgrAddEx(GetBootStageHookMgr(), &info);
     InitAddServiceHook(SetServiceBootEventFork, INIT_SERVICE_FORK_BEFORE);
     InitAddServiceHook(SetServiceBootEventFork, INIT_SERVICE_FORK_AFTER);
-    InitAddServiceHook(ClearServiceBootEvent, INIT_SERVICE_CLEAR);
+    InitAddClearServiceHook(ClearServiceBootEvent);
     InitAddServiceParseHook(ServiceParseBootEventHook);
     InitAddGlobalInitHook(0, ParamSetBootEventHook);
     InitAddPostPersistParamLoadHook(0, GetBootEventFlag);

services/modules/init_hook/init_hook.c

@@ -199,9 +199,9 @@ static void DumpServiceHook(void)
     // check and dump all jobs
     char dump[8] = {0}; // 8 len
     uint32_t len = sizeof(dump);
-    int ret = SystemReadParam("persist.init.debug.dump.trigger", dump, &len);
-    PLUGIN_LOGV("boot dump %s ret %d", dump, ret);
-    if (ret == 0 && strcmp(dump, "1") == 0) {
+    (void)SystemReadParam("persist.init.debug.dump.trigger", dump, &len);
+    PLUGIN_LOGV("boot dump trigger %s", dump);
+    if (strcmp(dump, "1") == 0) {
         SystemDumpTriggers(1, DumpTrigger);
     }
     return;

services/modules/reboot/reboot_static.c

@@ -156,7 +156,9 @@ const ParamCmdInfo *GetStartupPowerCtl(size_t *size)
 
 static void InitRebootHook_(RebootHookCtx *ctx)
 {
+#ifndef STARTUP_INIT_TEST // do not install
     InitModuleMgrInstall("rebootmodule");
+#endif
     PLUGIN_LOGI("Install rebootmodule.");
 }
 

services/modules/selinux/selinux_adp.c

@@ -56,7 +56,9 @@ static int SetServiceContent(int id, const char *name, int argc, const char **ar
     if (data != NULL) {
         if (setexeccon((char *)data->data) < 0) {
             PLUGIN_LOGE("failed to set service %s's secon (%s).", argv[0], (char *)data->data);
+#ifndef STARTUP_INIT_TEST
             _exit(PROCESS_EXIT_CODE);
+#endif
         } else {
             PLUGIN_LOGV("Set content %s to %s.", (char *)data->data, argv[0]);
         }
@@ -70,17 +72,19 @@ static int SetServiceContent(int id, const char *name, int argc, const char **ar
 
 static int SetSockCreateCon(int id, const char *name, int argc, const char **argv)
 {
-    PLUGIN_CHECK(name != NULL && argc >= 1 && argv != NULL, return -1, "Invalid parameter");
-    if (strcmp(argv[0], "") == 0) {
+    PLUGIN_CHECK(name != NULL, return -1, "Invalid parameter");
+    if (argc == 0) {
         setsockcreatecon(NULL);
         return 0;
     }
-
+    PLUGIN_CHECK(argc >= 1 && argv != NULL, return -1, "Invalid parameter");
     ServiceExtData *data = GetServiceExtData(argv[0], HOOK_ID_SELINUX);
     if (data != NULL) {
         if (setsockcreatecon((char *)data->data) < 0) {
             PLUGIN_LOGE("failed to set socket context %s's secon (%s).", argv[0], (char *)data->data);
+#ifndef STARTUP_INIT_TEST
             _exit(PROCESS_EXIT_CODE);
+#endif
         }
     }
 

services/modules/selinux/selinux_static.c

@@ -21,7 +21,9 @@
 static int SelinuxHook(const HOOK_INFO *hookInfo, void *cookie)
 {
     PLUGIN_LOGI("Install selinuxadp.");
+#ifndef STARTUP_INIT_TEST // do not install
     InitModuleMgrInstall("selinuxadp");
+#endif
     return 0;
 }
 

services/param/adapter/param_dac.c

@@ -29,7 +29,11 @@
 #define MAX_BUF_SIZE  1024
 #define GROUP_FORMAT "const.group"
 #define INVALID_MODE 0550
+#ifdef STARTUP_INIT_TEST
+#define GROUP_FILE_PATH STARTUP_INIT_UT_PATH "/etc/group"
+#else
 #define GROUP_FILE_PATH "/etc/group"
+#endif
 #define OCT_BASE 8
 #define INVALID_UID(uid) ((uid) == (uid_t)-1)
 

services/param/adapter/param_persistadp.c

@@ -27,10 +27,9 @@ static ParamMutex g_saveMutex = {};
 
 static int LoadOnePersistParam_(const uint32_t *context, const char *name, const char *value)
 {
+    UNUSED(context);
     uint32_t dataIndex = 0;
-    int ret = WriteParam(name, value, &dataIndex, 0);
-    PARAM_CHECK(ret == 0, return ret, "Failed to write param %d name:%s %s", ret, name, value);
-    return 0;
+    return WriteParam(name, value, &dataIndex, 0);
 }
 
 static int LoadPersistParam()
@@ -48,10 +47,9 @@ static int LoadPersistParam()
 
     const int buffSize = PARAM_NAME_LEN_MAX + PARAM_CONST_VALUE_LEN_MAX + 10;  // 10 max len
     char *buffer = malloc(buffSize);
-    if (buffer == NULL) {
-        (void)fclose(fp);
-        return -1;
-    }
+    PARAM_CHECK(buffer != NULL, (void)fclose(fp);
+        return -1, "Failed to alloc");
+
     uint32_t paramNum = 0;
     while (fgets(buffer, buffSize, fp) != NULL) {
         buffer[buffSize - 1] = '\0';
@@ -101,9 +99,8 @@ static int BatchSavePersistParam(PERSIST_SAVE_HANDLE handle, const char *name, c
 {
     FILE *fp = (FILE *)handle;
     int ret = fprintf(fp, "%s=%s\n", name, value);
-    PARAM_CHECK(ret > 0, return -1, "Failed to write param");
     PARAM_LOGV("BatchSavePersistParam %s=%s", name, value);
-    return 0;
+    return (ret > 0) ? 0 : -1;
 }
 
 static void BatchSavePersistParamEnd(PERSIST_SAVE_HANDLE handle)

services/param/adapter/param_selinux.c

@@ -216,19 +216,19 @@ static int SelinuxGetParamSecurityLabel(const char *path)
 static int CheckFilePermission(const ParamSecurityLabel *localLabel, const char *fileName, int flags)
 {
     UNUSED(flags);
-    PARAM_CHECK(localLabel != NULL && fileName != NULL, return -1, "Invalid param");
+    UNUSED(localLabel);
+    UNUSED(fileName);
     return 0;
 }
 
 static const char *GetSelinuxContent(const char *name)
 {
     SelinuxSpace *selinuxSpace = &GetParamWorkSpace()->selinuxSpace;
+    const char *content = WORKSPACE_NAME_DEF_SELINUX;
     if (selinuxSpace->getParamLabel != NULL) {
-        return selinuxSpace->getParamLabel(name);
-    } else {
-        PARAM_LOGE("Can not init selinux");
-        return WORKSPACE_NAME_DEF_SELINUX;
+        content = selinuxSpace->getParamLabel(name);
     }
+    return content;
 }
 
 static int CheckContentPermission(const char *name, const char *label)

services/param/base/param_base.c

@@ -52,6 +52,7 @@ static void WorkSpaceFree(const HashNode *node)
     WorkSpace *workSpace = HASHMAP_ENTRY(node, WorkSpace, hashNode);
     CloseWorkSpace(workSpace);
 }
+
 static int InitParamSecurity(ParamWorkSpace *workSpace,
     RegisterSecurityOpsPtr registerOps, ParamSecurityType type, int isInit, int op)
 {
@@ -100,7 +101,7 @@ static int CheckNeedInit(int onlyRead, const PARAM_WORKSPACE_OPS *ops)
 {
     if (ops != NULL) {
         g_paramWorkSpace.ops.updaterMode = ops->updaterMode;
-        if (g_paramWorkSpace.ops.logFunc == NULL) {
+        if (g_paramWorkSpace.ops.logFunc == NULL && ops->logFunc != NULL) {
             g_paramWorkSpace.ops.logFunc = ops->logFunc;
         }
 #ifdef PARAM_SUPPORT_SELINUX
@@ -113,20 +114,12 @@ static int CheckNeedInit(int onlyRead, const PARAM_WORKSPACE_OPS *ops)
     if (onlyRead == 0) {
         return 1;
     }
-#if !(defined __LITEOS_A__ || defined __LITEOS_M__)
-    if (getpid() == 1) { // init process only for write
-        return 0;
-    }
+#ifdef STARTUP_INIT_TEST
     // for ut, do not init workspace
     char path[PATH_MAX] = { 0 };
     (void)readlink("/proc/self/exe", path, sizeof(path) - 1);
-    char *name = strrchr(path, '/');
+    char *name = strstr(path, "/init_unittest");
     if (name != NULL) {
-        name++;
-    } else {
-        name = path;
-    }
-    if (strcmp(name, "init_unittest") == 0) {
         PARAM_LOGW("Can not init client for init_test");
         return 0;
     }
@@ -182,7 +175,7 @@ INIT_INNER_API int InitParamWorkSpace(int onlyRead, const PARAM_WORKSPACE_OPS *o
 
 INIT_LOCAL_API void CloseParamWorkSpace(void)
 {
-    PARAM_LOGI("CloseParamWorkSpace %p", &g_paramWorkSpace);
+    PARAM_LOGI("CloseParamWorkSpace %x", g_paramWorkSpace.flags);
     if (!PARAM_TEST_FLAG(g_paramWorkSpace.flags, WORKSPACE_FLAGS_INIT)) {
         return;
     }
@@ -216,7 +209,7 @@ INIT_LOCAL_API void ParamWorBaseLog(InitLogLevel logLevel, uint32_t domain, cons
 INIT_INNER_API ParamWorkSpace *GetParamWorkSpace(void)
 {
     if (!PARAM_TEST_FLAG(g_paramWorkSpace.flags, WORKSPACE_FLAGS_INIT)) {
-        PARAM_LOGE("GetParamWorkSpace %p", &g_paramWorkSpace);
+        PARAM_LOGE("Invalid param workspace %x", g_paramWorkSpace.flags);
         return NULL;
     }
     return &g_paramWorkSpace;

services/param/base/param_comm.c

@@ -542,10 +542,7 @@ INIT_LOCAL_API int CheckParamPermission(const ParamSecurityLabel *srcLabel, cons
             continue;
         }
         ParamSecurityOps *ops = GetParamSecurityOps(i);
-        if (ops == NULL) {
-            continue;
-        }
-        if (ops->securityCheckParamPermission == NULL) {
+        if (ops == NULL || ops->securityCheckParamPermission == NULL) {
             continue;
         }
         ret = ops->securityCheckParamPermission(srcLabel, name, mode);

services/param/base/param_trie.c

@@ -135,9 +135,19 @@ INIT_LOCAL_API void CloseWorkSpace(WorkSpace *workSpace)
     free(workSpace);
 }
 
+static int CheckWorkSpace(const WorkSpace *workSpace)
+{
+    PARAM_CHECK(workSpace != NULL && workSpace->area != NULL, return -1, "The workspace is null");
+    if (!PARAM_TEST_FLAG(workSpace->flags, WORKSPACE_FLAGS_INIT)) {
+        return -1;
+    }
+    PARAM_CHECK(workSpace->allocTrieNode != NULL, return -1, "Invalid allocTrieNode");
+    PARAM_CHECK(workSpace->compareTrieNode != NULL, return -1, "Invalid compareTrieNode");
+    return 0;
+}
+
 static ParamTrieNode *GetTrieRoot(const WorkSpace *workSpace)
 {
-    PARAM_CHECK(workSpace != NULL && workSpace->area != NULL, return NULL, "The workspace is null");
     return (ParamTrieNode *)(workSpace->area->data + workSpace->area->firstNode);
 }
 
@@ -153,7 +163,7 @@ static void GetNextKey(const char **remainingKey, char **subKey, uint32_t *subKe
 
 static ParamTrieNode *AddToSubTrie(WorkSpace *workSpace, ParamTrieNode *current, const char *key, uint32_t keyLen)
 {
-    if (current == NULL || workSpace == NULL || key == NULL) {
+    if (current == NULL) {
         return NULL;
     }
     ParamTrieNode *subTrie = NULL;
@@ -186,9 +196,7 @@ static ParamTrieNode *AddToSubTrie(WorkSpace *workSpace, ParamTrieNode *current,
 ParamTrieNode *AddTrieNode(WorkSpace *workSpace, const char *key, uint32_t keyLen)
 {
     PARAM_CHECK(key != NULL && keyLen > 0, return NULL, "Invalid param ");
-    PARAM_CHECK(workSpace != NULL && workSpace->area != NULL, return 0, "Invalid workSpace %s", key);
-    PARAM_CHECK(workSpace->allocTrieNode != NULL, return NULL, "Invalid param %s", key);
-    PARAM_CHECK(workSpace->compareTrieNode != NULL, return NULL, "Invalid param %s", key);
+    PARAM_CHECK(CheckWorkSpace(workSpace) == 0, return 0, "Invalid workSpace %s", key);
     const char *remainingKey = key;
     ParamTrieNode *current = GetTrieRoot(workSpace);
     PARAM_CHECK(current != NULL, return NULL, "Invalid current param %s", key);
@@ -250,10 +258,6 @@ static ParamTrieNode *FindSubTrie(const WorkSpace *workSpace,
 
 static ParamTrieNode *FindTrieNode_(const WorkSpace *workSpace, const char *key, uint32_t keyLen, uint32_t *matchLabel)
 {
-    PARAM_CHECK(key != NULL && keyLen > 0, return NULL, "Invalid key ");
-    PARAM_CHECK(workSpace != NULL && workSpace->area != NULL, return 0, "Invalid workSpace %s", key);
-    PARAM_CHECK(workSpace->allocTrieNode != NULL, return NULL, "Invalid alloc function %s", key);
-    PARAM_CHECK(workSpace->compareTrieNode != NULL, return NULL, "Invalid compare function %s", key);
     const char *remainingKey = key;
     ParamTrieNode *current = GetTrieRoot(workSpace);
     PARAM_CHECK(current != NULL, return NULL, "Invalid current param %s", key);
@@ -307,14 +311,13 @@ INIT_LOCAL_API int TraversalTrieNode(const WorkSpace *workSpace,
     const ParamTrieNode *root, TraversalTrieNodePtr walkFunc, const void *cookie)
 {
     PARAM_CHECK(walkFunc != NULL, return PARAM_CODE_INVALID_PARAM, "Invalid param");
-    PARAM_CHECK(workSpace != NULL && workSpace->area != NULL, return 0, "Invalid workSpace");
+    PARAM_CHECK(CheckWorkSpace(workSpace) == 0, return PARAM_CODE_INVALID_PARAM, "Invalid workSpace");
     ParamTrieNode *current = (ParamTrieNode *)root;
     if (root == NULL) {
         current = GetTrieRoot(workSpace);
     }
-    if (current == NULL) {
-        return 0;
-    }
+    PARAM_CHECK(current != NULL, return 0, "Invalid current node");
+
     walkFunc(workSpace, (ParamTrieNode *)current, cookie);
     TraversalSubTrieNode(workSpace, GetTrieNode(workSpace, current->child), walkFunc, cookie);
     if (root == NULL) {
@@ -326,8 +329,8 @@ INIT_LOCAL_API int TraversalTrieNode(const WorkSpace *workSpace,
 
 INIT_LOCAL_API uint32_t AddParamSecurityNode(WorkSpace *workSpace, const ParamAuditData *auditData)
 {
-    PARAM_CHECK(workSpace != NULL && workSpace->area != NULL, return 0, "Invalid param");
-    PARAM_CHECK(auditData != NULL && auditData->name != NULL, return 0, "Invalid auditData");
+    PARAM_CHECK(CheckWorkSpace(workSpace) == 0, return 0, "Invalid workSpace");
+    PARAM_CHECK(auditData != NULL, return 0, "Invalid auditData");
     uint32_t realLen = sizeof(ParamSecurityNode);
     PARAM_CHECK((workSpace->area->currOffset + realLen) < workSpace->area->dataSize, return 0,
         "Failed to allocate currOffset %u, dataSize %u datalen %u",
@@ -346,8 +349,8 @@ INIT_LOCAL_API uint32_t AddParamSecurityNode(WorkSpace *workSpace, const ParamAu
 INIT_LOCAL_API uint32_t AddParamNode(WorkSpace *workSpace, uint8_t type,
     const char *key, uint32_t keyLen, const char *value, uint32_t valueLen)
 {
-    PARAM_CHECK(workSpace != NULL && workSpace->area != NULL, return 0, "Invalid param");
     PARAM_CHECK(key != NULL && value != NULL, return 0, "Invalid param");
+    PARAM_CHECK(CheckWorkSpace(workSpace) == 0, return 0, "Invalid workSpace %s", key);
 
     uint32_t realLen = sizeof(ParamNode) + 1 + 1;
     // for const parameter, alloc memory on demand
@@ -377,7 +380,7 @@ INIT_LOCAL_API uint32_t AddParamNode(WorkSpace *workSpace, uint8_t type,
 
 INIT_LOCAL_API ParamTrieNode *GetTrieNode(const WorkSpace *workSpace, uint32_t offset)
 {
-    PARAM_CHECK(workSpace != NULL && workSpace->area != NULL, return NULL, "Invalid param");
+    PARAM_CHECK(CheckWorkSpace(workSpace) == 0, return NULL, "Invalid workSpace");
     if (offset == 0 || offset > workSpace->area->dataSize) {
         return NULL;
     }
@@ -393,7 +396,9 @@ INIT_LOCAL_API void SaveIndex(uint32_t *index, uint32_t offset)
 INIT_LOCAL_API ParamTrieNode *FindTrieNode(WorkSpace *workSpace,
     const char *key, uint32_t keyLen, uint32_t *matchLabel)
 {
-    PARAM_CHECK(workSpace != NULL && workSpace->area != NULL, return NULL, "Invalid workSpace");
+    PARAM_CHECK(key != NULL && keyLen > 0, return NULL, "Invalid key ");
+    PARAM_CHECK(CheckWorkSpace(workSpace) == 0, return NULL, "Invalid workSpace %s", key);
+
     ParamTrieNode *node = NULL;
     PARAMSPACE_AREA_RD_LOCK(workSpace);
     node = FindTrieNode_(workSpace, key, keyLen, matchLabel);
@@ -423,7 +428,6 @@ INIT_LOCAL_API ParamNode *GetParamNode(const char *spaceName, const char *name)
 {
     uint32_t labelIndex = 0;
     WorkSpace *space = GetWorkSpace(spaceName);
-    PARAM_CHECK(space != NULL, return NULL, "Failed to get dac space %s", name);
     ParamTrieNode *entry = FindTrieNode(space, name, strlen(name), &labelIndex);
     if (entry == NULL || entry->dataIndex == 0) {
         return NULL;

services/param/include/param_osadp.h

@@ -193,11 +193,13 @@ INIT_LOCAL_API void FreeSharedMem(const MemHandle *handle, void *mem, uint32_t d
 #define ATOMIC_LOAD_EXPLICIT(commitId, order) atomic_load_explicit((commitId), (order))
 #define ATOMIC_STORE_EXPLICIT(commitId, value, order) atomic_store_explicit((commitId), (value), (order))
 #endif
+
+INIT_LOCAL_API uint32_t Difftime(time_t curr, time_t base);
+
 #ifdef __cplusplus
 #if __cplusplus
 }
 #endif
 #endif
 
-INIT_LOCAL_API uint32_t Difftime(time_t curr, time_t base);
 #endif // BASE_STARTUP_PARAM_MESSAGE_H
\ No newline at end of file

services/param/linux/param_message.c

@@ -44,7 +44,7 @@ int ConnectServer(int fd, const char *servername)
 int FillParamMsgContent(const ParamMessage *request, uint32_t *start, int type, const char *value, uint32_t length)
 {
     PARAM_CHECK(request != NULL && start != NULL, return -1, "Invalid param");
-    PARAM_CHECK(value != NULL && length > 0 && length < PARAM_BUFFER_MAX, return -1, "Invalid value");
+    PARAM_CHECK(value != NULL && length != 0, return -1, "Invalid value");
     uint32_t bufferSize = request->msgSize - sizeof(ParamMessage);
     uint32_t offset = *start;
     PARAM_CHECK((offset + sizeof(ParamMsgContent) + length) <= bufferSize,
@@ -63,6 +63,7 @@ int FillParamMsgContent(const ParamMessage *request, uint32_t *start, int type,
 ParamMessage *CreateParamMessage(int type, const char *name, uint32_t msgSize)
 {
     PARAM_CHECK(name != NULL, return NULL, "Invalid name");
+    PARAM_CHECK(msgSize < PARAM_BUFFER_MAX, return NULL, "Invalid msg size %u", msgSize);
     uint32_t size = msgSize;
     if (msgSize < sizeof(ParamMessage)) {
         size = sizeof(ParamMessage);
@@ -78,12 +79,12 @@ ParamMessage *CreateParamMessage(int type, const char *name, uint32_t msgSize)
     return msg;
 }
 
-ParamMsgContent *GetNextContent(const ParamMessage *reqest, uint32_t *offset)
+ParamMsgContent *GetNextContent(const ParamMessage *request, uint32_t *offset)
 {
-    PARAM_CHECK(reqest != NULL, return NULL, "Invalid reqest");
+    PARAM_CHECK(request != NULL, return NULL, "Invalid request");
     PARAM_CHECK(offset != NULL, return NULL, "Invalid offset");
-    ParamMessage *msg = (ParamMessage *)reqest;
-    if ((msg == NULL) || ((*offset + sizeof(ParamMessage) + sizeof(ParamMsgContent)) >= msg->msgSize)) {
+    ParamMessage *msg = (ParamMessage *)request;
+    if ((*offset + sizeof(ParamMessage) + sizeof(ParamMsgContent)) >= msg->msgSize) {
         return NULL;
     }
     ParamMsgContent *content = (ParamMsgContent *)(msg->data + *offset);

services/param/linux/param_service.c

@@ -166,7 +166,9 @@ static int HandleParamSet(const ParamTaskPtr worker, const ParamMessage *msg)
     socklen_t crSize = sizeof(cr);
     if (getsockopt(LE_GetSocketFd(worker), SOL_SOCKET, SO_PEERCRED, &cr, &crSize) < 0) {
         PARAM_LOGE("Failed to get opt %d", errno);
+#ifndef STARTUP_INIT_TEST
         return SendResponseMsg(worker, msg, -1);
+#endif
     }
     srcLabel.sockFd = LE_GetSocketFd(worker);
     srcLabel.cred.uid = cr.uid;
@@ -337,6 +339,9 @@ PARAM_STATIC int ProcessMessage(const ParamTaskPtr worker, const ParamMessage *m
 PARAM_STATIC int OnIncomingConnect(LoopHandle loop, TaskHandle server)
 {
     ParamStreamInfo info = {};
+#ifdef STARTUP_INIT_TEST
+    info.flags = PARAM_TEST_FLAGS;
+#endif
     info.server = NULL;
     info.close = OnClose;
     info.recvMessage = ProcessMessage;

services/param/manager/param_server.c

@@ -170,10 +170,9 @@ static int LoadDefaultParam_(const char *fileName, uint32_t mode,
 
     const int buffSize = PARAM_NAME_LEN_MAX + PARAM_CONST_VALUE_LEN_MAX + 10;  // 10 max len
     char *buffer = malloc(buffSize);
-    if (buffer == NULL) {
-        (void)fclose(fp);
-        return -1;
-    }
+    PARAM_CHECK(buffer != NULL, (void)fclose(fp);
+        return -1, "Failed to alloc memory");
+
     while (fgets(buffer, buffSize, fp) != NULL) {
         buffer[buffSize - 1] = '\0';
         int ret = SplitParamString(buffer, exclude, count, loadOneParam, &mode);

services/param/watcher/agent/watcher_manager_kits.cpp

@@ -77,9 +77,6 @@ sptr<IWatcherManager> WatcherManagerKits::GetService(void)
         WATCHER_LOGE("Failed to add death recipient");
     }
     watcherManager_ = iface_cast<IWatcherManager>(object);
-    if (watcherManager_ == nullptr) {
-        WATCHER_LOGE("watcher manager iface_cast failed");
-    }
     return watcherManager_;
 }
 
@@ -110,12 +107,6 @@ void WatcherManagerKits::ReAddWatcher(void)
     WATCHER_CHECK(remoteWatcherId > 0, return, "Failed to get remote agent");
     std::lock_guard<std::mutex> lock(mutex_);
     for (auto iter = watchers_.begin(); iter != watchers_.end(); iter++) {
-        if (stop_) {
-            return;
-        }
-        if (iter->second == nullptr) {
-            continue;
-        }
         WATCHER_LOGI("Add old watcher keyPrefix %s ", iter->first.c_str());
         int ret = watcherManager->AddWatcher(iter->first, remoteWatcherId);
         WATCHER_CHECK(ret == 0, continue, "Failed to add watcher for %s", iter->first.c_str());
@@ -283,6 +274,7 @@ int WatcherManagerKits::ParamWatcher::DelParameterListener(ParameterChangePtr ca
 void WatcherManagerKits::RemoteWatcher::OnParameterChange(
     const std::string &prefix, const std::string &name, const std::string &value)
 {
+    Watcher::OnParameterChange(prefix, name, value);
     // get param watcher
     WatcherManagerKits::ParamWatcher *watcher = watcherManager_->GetParamWatcher(prefix);
     WATCHER_CHECK(watcher != nullptr, return, "Failed to get watcher '%s'", prefix.c_str());

services/param/watcher/agent/watcher_manager_kits.h

@@ -26,10 +26,11 @@
 #include "init_param.h"
 #include "watcher.h"
 #include "watcher_utils.h"
+#include "beget_ext.h"
 
 namespace OHOS {
 namespace init_param {
-class WatcherManagerKits final : public DelayedRefSingleton<WatcherManagerKits> {
+class INIT_LOCAL_API WatcherManagerKits final : public DelayedRefSingleton<WatcherManagerKits> {
     DECLARE_DELAYED_REF_SINGLETON(WatcherManagerKits);
 public:
     DISALLOW_COPY_AND_MOVE(WatcherManagerKits);
@@ -38,10 +39,7 @@ public:
     int32_t AddWatcher(const std::string &keyPrefix, ParameterChangePtr callback, void *context);
     int32_t DelWatcher(const std::string &keyPrefix, ParameterChangePtr callback, void *context);
     void ReAddWatcher(void);
-
-#ifndef STARTUP_INIT_TEST
 private:
-#endif
     class ParameterChangeListener {
     public:
         ParameterChangeListener(ParameterChangePtr callback, void *context)

services/param/watcher/agent/watcher_manager_proxy.cpp

@@ -14,15 +14,13 @@
  */
 #include "watcher_manager_proxy.h"
 #include "watcher_utils.h"
+#include "sysparam_errno.h"
 
 namespace OHOS {
 namespace init_param {
 uint32_t WatcherManagerProxy::AddRemoteWatcher(uint32_t id, const sptr<IWatcher> &watcher)
 {
     WATCHER_CHECK(watcher != nullptr, return ERR_INVALID_VALUE, "Invalid param");
-    auto remote = Remote();
-    WATCHER_CHECK(remote != nullptr, return 0, "Can not get remote");
-
     MessageParcel data;
     data.WriteInterfaceToken(WatcherManagerProxy::GetDescriptor());
     bool ret = data.WriteRemoteObject(watcher->AsObject());
@@ -31,38 +29,32 @@ uint32_t WatcherManagerProxy::AddRemoteWatcher(uint32_t id, const sptr<IWatcher>
 
     MessageParcel reply;
     MessageOption option { MessageOption::TF_SYNC };
-    int32_t res = remote->SendRequest(ADD_REMOTE_AGENT, data, reply, option);
+    int32_t res = SendWatcherMsg(ADD_REMOTE_AGENT, data, reply, option);
     WATCHER_CHECK(res == ERR_OK, return 0, "Transact error %d", res);
     return reply.ReadUint32();
 }
 
 int32_t WatcherManagerProxy::DelRemoteWatcher(uint32_t remoteWatcherId)
 {
-    auto remote = Remote();
-    WATCHER_CHECK(remote != nullptr, return ERR_FLATTEN_OBJECT, "Can not get remote");
-
     MessageParcel data;
     data.WriteInterfaceToken(WatcherManagerProxy::GetDescriptor());
     data.WriteUint32(remoteWatcherId);
     MessageParcel reply;
     MessageOption option { MessageOption::TF_SYNC };
-    int32_t res = remote->SendRequest(DEL_REMOTE_AGENT, data, reply, option);
+    int32_t res = SendWatcherMsg(DEL_REMOTE_AGENT, data, reply, option);
     WATCHER_CHECK(res == ERR_OK, return ERR_FLATTEN_OBJECT, "Transact error");
     return reply.ReadInt32();
 }
 
 int32_t WatcherManagerProxy::SendMsg(int op, const std::string &keyPrefix, uint32_t remoteWatcherId)
 {
-    auto remote = Remote();
-    WATCHER_CHECK(remote != nullptr, return 0, "Can not get remote");
-
     MessageParcel data;
     data.WriteInterfaceToken(WatcherManagerProxy::GetDescriptor());
     data.WriteString(keyPrefix);
     data.WriteUint32(remoteWatcherId);
     MessageParcel reply;
     MessageOption option { MessageOption::TF_SYNC };
-    int32_t res = remote->SendRequest(op, data, reply, option);
+    int32_t res = SendWatcherMsg(op, data, reply, option);
     WATCHER_CHECK(res == ERR_OK, return 0, "Transact error");
     return reply.ReadInt32();
 }
@@ -81,5 +73,19 @@ int32_t WatcherManagerProxy::RefreshWatcher(const std::string &keyPrefix, uint32
 {
     return SendMsg(REFRESH_WATCHER, keyPrefix, remoteWatcherId);
 }
+
+int32_t WatcherManagerProxy::SendWatcherMsg(uint32_t code,
+    MessageParcel &data, MessageParcel &reply, MessageOption &option)
+{
+    auto remote = Remote();
+    if (remote != nullptr) {
+        return remote->SendRequest(code, data, reply, option);
+    }
+#ifdef STARTUP_INIT_TEST
+    return 0;
+#else
+    return SYSPARAM_SYSTEM_ERROR;
+#endif
+}
 }
 } // namespace OHOS

services/param/watcher/agent/watcher_manager_proxy.h

@@ -18,10 +18,11 @@
 
 #include "iremote_proxy.h"
 #include "iwatcher_manager.h"
+#include "beget_ext.h"
 
 namespace OHOS {
 namespace init_param {
-class WatcherManagerProxy : public IRemoteProxy<IWatcherManager> {
+class INIT_LOCAL_API WatcherManagerProxy : public IRemoteProxy<IWatcherManager> {
 public:
     explicit WatcherManagerProxy(const sptr<IRemoteObject> &impl) : IRemoteProxy<IWatcherManager>(impl) {}
 
@@ -32,6 +33,8 @@ public:
     int32_t RefreshWatcher(const std::string &keyPrefix, uint32_t remoteWatcherId) override;
 private:
     int32_t SendMsg(int op, const std::string &keyPrefix, uint32_t remoteWatcherId);
+    int32_t SendWatcherMsg(uint32_t code,
+        MessageParcel &data, MessageParcel &reply, MessageOption &option);
     static inline BrokerDelegator<WatcherManagerProxy> delegator_;
 };
 } // namespace init_param

services/param/watcher/agent/watcher_stub.cpp

@@ -28,9 +28,9 @@ int32_t WatcherStub::OnRemoteRequest(uint32_t code, MessageParcel &data, Message
 
     switch (code) {
         case PARAM_CHANGE: {
-            std::string key = data.ReadString();
-            std::string name = data.ReadString();
-            std::string value = data.ReadString();
+            std::string key(data.ReadString());
+            std::string name(data.ReadString());
+            std::string value(data.ReadString());
             OnParameterChange(key, name, value);
             break;
         }

services/param/watcher/proxy/watcher_manager.cpp

@@ -215,6 +215,7 @@ void WatcherManager::SendLocalChange(const std::string &keyPrefix, RemoteWatcher
             if (!FilterParam(context->buffer, context->keyPrefix)) {
                 return;
             }
+            WATCHER_LOGV("SendLocalChange name '%s' prefix '%s'", context->buffer, context->keyPrefix.c_str());
             uint32_t size = PARAM_CONST_VALUE_LEN_MAX;
             SystemGetParameterValue(handle, context->buffer + PARAM_NAME_LEN_MAX, &size);
             context->remoteWatcher->ProcessParameterChange(
@@ -230,12 +231,12 @@ void WatcherManager::RunLoop()
     ssize_t recvLen = 0;
     while (!stop_) {
         int fd = GetServerFd(retry);
-        if (fd >= 0) {
-            recvLen = recv(fd, buffer.data(), RECV_BUFFER_MAX, 0);
-        }
         if (stop_) {
             break;
         }
+        if (fd >= 0) {
+            recvLen = recv(fd, buffer.data(), RECV_BUFFER_MAX, 0);
+        }
         if (recvLen <= 0) {
             if (errno == EAGAIN) { // timeout
                 continue;
@@ -258,11 +259,11 @@ void WatcherManager::RunLoop()
             curr += msg->msgSize;
         }
     }
-    if (serverFd_ > 0) {
+    if (serverFd_ >= 0) {
         close(serverFd_);
         serverFd_ = INVALID_SOCKET;
     }
-    WATCHER_LOGV("Exit runLoop");
+    WATCHER_LOGV("Exit runLoop serverFd %d", serverFd_);
 }
 
 void WatcherManager::StartLoop()
@@ -298,6 +299,9 @@ int WatcherManager::GetServerFd(bool retry)
         serverFd_ = INVALID_SOCKET;
         usleep(sleepTime);
         retryCount++;
+        if (stop_) {
+            break;
+        }
     } while (retryCount < maxRetry);
     WATCHER_LOGV("GetServerFd serverFd_ %d retryCount %d ", serverFd_, retryCount);
     return serverFd_;
@@ -324,7 +328,7 @@ void WatcherManager::StopLoop()
 {
     WATCHER_LOGI("Watcher manager StopLoop serverFd_ %d", serverFd_);
     stop_ = true;
-    if (serverFd_ > 0) {
+    if (serverFd_ >= 0) {
         shutdown(serverFd_, SHUT_RDWR);
         close(serverFd_);
         serverFd_ = INVALID_SOCKET;
@@ -428,9 +432,6 @@ void WatcherManager::DumpAllGroup(int fd, ParamWatcherProcessor dumpHandle)
     std::lock_guard<std::mutex> lock(watcherMutex_);
     for (auto it = groupMap_.begin(); it != groupMap_.end(); ++it) {
         auto group = it->second;
-        if (group == nullptr) {
-            continue;
-        }
         dprintf(fd, "Watch prefix   : %s \n", group->GetKeyPrefix().c_str());
         dprintf(fd, "Watch group id : %u \n", group->GetGroupId());
         dprintf(fd, "Watch count    : %zu \n", group->GetNodeCount());
@@ -492,15 +493,18 @@ int WatcherManager::Dump(int fd, const std::vector<std::u16string>& args)
 
 void WatcherManager::Clear(void)
 {
+    WATCHER_LOGV("Clear");
     std::lock_guard<std::mutex> lock(watcherMutex_);
     remoteWatchers_->TraversalNodeSafe([](ParamWatcherListPtr list, WatcherNodePtr node, uint32_t index) {
         list->RemoveNode(node);
         auto group = ConvertTo<WatcherGroup>(node);
+        WATCHER_LOGV("Delete watcher group %u", group->GetGroupId());
         delete group;
     });
     watcherGroups_->TraversalNodeSafe([](ParamWatcherListPtr list, WatcherNodePtr node, uint32_t index) {
         list->RemoveNode(node);
         auto remoteWatcher = ConvertTo<RemoteWatcher>(node);
+        WATCHER_LOGV("Delete remote watcher %u", remoteWatcher->GetRemoteWatcherId());
         delete remoteWatcher;
     });
     delete remoteWatchers_;
@@ -740,5 +744,27 @@ int WatcherNode::Greater(ListNodePtr node, void *data)
     uint32_t id = *(uint32_t *)data;
     return (watcher->nodeId_ > id) ? 0 : 1;
 }
+
+WatcherGroup::~WatcherGroup(void)
+{
+    TraversalNodeSafe([](ParamWatcherListPtr list, WatcherNodePtr node, uint32_t index) {
+        list->RemoveNode(node);
+        ParamWatcher *watcher = ConvertTo<ParamWatcher>(node);
+        WATCHER_LOGV("delete watcher group %u", watcher->GetNodeId());
+        delete watcher;
+    });
+}
+
+RemoteWatcher::~RemoteWatcher(void)
+{
+    watcher_ = nullptr;
+    WATCHER_LOGI("RemoteWatcher ");
+    TraversalNodeSafe([](ParamWatcherListPtr list, WatcherNodePtr node, uint32_t index) {
+        list->RemoveNode(node);
+        ParamWatcher *watcher = ConvertTo<ParamWatcher>(node);
+        WATCHER_LOGV("delete remote watcher %u", watcher->GetNodeId());
+        delete watcher;
+    });
+}
 } // namespace init_param
 } // namespace OHOS

services/param/watcher/proxy/watcher_manager.h

@@ -78,15 +78,11 @@ public:
     int32_t AddWatcher(const std::string &keyPrefix, uint32_t remoteWatcherId) override;
     int32_t DelWatcher(const std::string &keyPrefix, uint32_t remoteWatcherId) override;
     int32_t RefreshWatcher(const std::string &keyPrefix, uint32_t remoteWatcherId) override;
-#ifndef STARTUP_INIT_TEST
 protected:
-#endif
     void OnStart() override;
     void OnStop() override;
     int Dump(int fd, const std::vector<std::u16string>& args) override;
-#ifndef STARTUP_INIT_TEST
 private:
-#endif
     void RunLoop();
     void StartLoop();
     void StopLoop();
@@ -220,15 +216,7 @@ class RemoteWatcher : public WatcherNode, public ParamWatcherList {
 public:
     RemoteWatcher(uint32_t watcherId, const sptr<IWatcher> &watcher)
         : WatcherNode(watcherId), ParamWatcherList(), watcher_(watcher) {}
-    ~RemoteWatcher(void) override
-    {
-        watcher_ = nullptr;
-        TraversalNodeSafe([](ParamWatcherListPtr list, WatcherNodePtr node, uint32_t index) {
-            list->RemoveNode(node);
-            ParamWatcher *watcher = ConvertTo<ParamWatcher>(node);
-            delete watcher;
-        });
-    }
+    ~RemoteWatcher(void) override;
 
     uint32_t GetRemoteWatcherId(void) const
     {
@@ -259,14 +247,8 @@ class WatcherGroup : public WatcherNode, public ParamWatcherList {
 public:
     WatcherGroup(uint32_t groupId, const std::string &key)
         : WatcherNode(groupId), ParamWatcherList(), keyPrefix_(key) {}
-    ~WatcherGroup() override
-    {
-        TraversalNodeSafe([](ParamWatcherListPtr list, WatcherNodePtr node, uint32_t index) {
-            list->RemoveNode(node);
-            ParamWatcher *watcher = ConvertTo<ParamWatcher>(node);
-            delete watcher;
-        });
-    }
+    ~WatcherGroup(void) override;
+
     void ProcessParameterChange(WatcherManager *mananger, const std::string &name, const std::string &value);
     const std::string GetKeyPrefix() const
     {

services/param/watcher/proxy/watcher_manager_stub.cpp

@@ -23,7 +23,7 @@ int32_t WatcherManagerStub::OnRemoteRequest(uint32_t code,
 {
     std::u16string myDescriptor = IWatcherManager::GetDescriptor();
     std::u16string remoteDescriptor = data.ReadInterfaceToken();
-    WATCHER_CHECK(myDescriptor == remoteDescriptor, return -1, "Invalid remoteDescriptor");
+    WATCHER_CHECK(myDescriptor == remoteDescriptor, return -1, "Invalid remoteDescriptor %u", code);
 
     WATCHER_LOGV("OnRemoteRequest code %u", code);
     switch (code) {
@@ -42,8 +42,6 @@ int32_t WatcherManagerStub::OnRemoteRequest(uint32_t code,
         case ADD_REMOTE_AGENT: {
             auto remote = data.ReadRemoteObject();
             // 0 is invalid watcherId
-            WATCHER_CHECK(remote != nullptr, reply.WriteUint32(0);
-                return 0, "Failed to read remote watcher");
             uint32_t id = data.ReadUint32();
             uint32_t remoteWatcherId = AddRemoteWatcher(id, iface_cast<IWatcher>(remote));
             reply.WriteUint32(remoteWatcherId);

services/param/watcher/proxy/watcher_proxy.cpp

@@ -20,23 +20,29 @@
 #include "message_parcel.h"
 #include "watcher_utils.h"
 #include "securec.h"
+#include "sysparam_errno.h"
 
 namespace OHOS {
 namespace init_param {
 void WatcherProxy::OnParameterChange(const std::string &prefix, const std::string &name, const std::string &value)
 {
-    WATCHER_LOGV("WatcherProxy::OnParameterChange %s %s %s", prefix.c_str(), name.c_str(), value.c_str());
     MessageParcel data;
     MessageParcel reply;
     MessageOption option { MessageOption::TF_ASYNC };
-    auto remote = Remote();
-    WATCHER_CHECK(remote != nullptr, return, "Can not get remote");
 
     data.WriteInterfaceToken(WatcherProxy::GetDescriptor());
     data.WriteString(prefix);
     data.WriteString(name);
     data.WriteString(value);
-    int ret = remote->SendRequest(PARAM_CHANGE, data, reply, option);
+    auto remote = Remote();
+#ifdef STARTUP_INIT_TEST
+    int ret = 0;
+#else
+    int ret = SYSPARAM_SYSTEM_ERROR;
+#endif
+    if (remote != nullptr) {
+        ret = remote->SendRequest(PARAM_CHANGE, data, reply, option);
+    }
     WATCHER_CHECK(ret == ERR_OK, return, "Can not SendRequest for name %s err:%d", name.c_str(), ret);
     return;
 }

services/utils/init_hashmap.c

@@ -29,9 +29,10 @@ typedef struct {
 static uint32_t g_tableId = 0;
 int32_t OH_HashMapCreate(HashMapHandle *handle, const HashInfo *info)
 {
-    INIT_ERROR_CHECK(handle != NULL && info != NULL && info->maxBucket > 0, return -1, "Invalid param");
-    INIT_ERROR_CHECK(info->keyHash != NULL && info->nodeHash != NULL, return -1, "Invalid param");
-    INIT_ERROR_CHECK(info->nodeCompare != NULL && info->keyCompare != NULL, return -1, "Invalid param");
+    INIT_ERROR_CHECK(handle != NULL, return -1, "Invalid hash handle");
+    INIT_ERROR_CHECK(info != NULL && info->maxBucket > 0, return -1, "Invalid hash info");
+    INIT_ERROR_CHECK(info->keyHash != NULL && info->nodeHash != NULL, return -1, "Invalid hash key");
+    INIT_ERROR_CHECK(info->nodeCompare != NULL && info->keyCompare != NULL, return -1, "Invalid hash compare");
     HashTab *tab = (HashTab *)calloc(1, sizeof(HashTab) + sizeof(HashNode*) * info->maxBucket);
     INIT_ERROR_CHECK(tab != NULL, return -1, "Failed to create hash tab");
     tab->maxBucket = info->maxBucket;
@@ -74,7 +75,7 @@ static HashNode *GetHashNodeByKey(const HashTab *tab, const HashNode *root, cons
 
 int32_t OH_HashMapAdd(HashMapHandle handle, HashNode *node)
 {
-    INIT_ERROR_CHECK(handle != NULL, return -1, "Invalid param");
+    INIT_ERROR_CHECK(handle != NULL, return -1, "Invalid hash handle");
     INIT_ERROR_CHECK(node != NULL && node->next == NULL, return -1, "Invalid param");
     HashTab *tab = (HashTab *)handle;
     int hashCode = tab->nodeHash(node);
@@ -90,13 +91,12 @@ int32_t OH_HashMapAdd(HashMapHandle handle, HashNode *node)
     }
     node->next = tab->buckets[hashCode];
     tab->buckets[hashCode] = node;
-    INIT_LOGV("OH_HashMapAdd tableId %d hashCode %d node %p", tab->tableId, hashCode, node);
     return 0;
 }
 
 void OH_HashMapRemove(HashMapHandle handle, const void *key)
 {
-    INIT_ERROR_CHECK(handle != NULL && key != NULL, return, "Invalid param");
+    INIT_ERROR_CHECK(handle != NULL && key != NULL, return, "Invalid hash handle key:%s", key);
     HashTab *tab = (HashTab *)handle;
     int hashCode = tab->keyHash(key);
     hashCode = (hashCode < 0) ? -hashCode : hashCode;
@@ -122,7 +122,7 @@ void OH_HashMapRemove(HashMapHandle handle, const void *key)
 
 HashNode *OH_HashMapGet(HashMapHandle handle, const void *key)
 {
-    INIT_ERROR_CHECK(handle != NULL && key != NULL, return NULL, "Invalid param %s", key);
+    INIT_ERROR_CHECK(handle != NULL && key != NULL, return NULL, "Invalid hash handle key:%s", key);
     HashTab *tab = (HashTab *)handle;
     int hashCode = tab->keyHash(key);
     hashCode = (hashCode < 0) ? -hashCode : hashCode;
@@ -149,7 +149,7 @@ static void HashListFree(HashTab *tab, HashNode *root)
 
 void OH_HashMapDestory(HashMapHandle handle)
 {
-    INIT_ERROR_CHECK(handle != NULL, return, "Invalid param");
+    INIT_ERROR_CHECK(handle != NULL, return, "Invalid hash handle");
     HashTab *tab = (HashTab *)handle;
     for (int i = 0; i < tab->maxBucket; i++) {
         HashListFree(tab, tab->buckets[i]);
@@ -160,8 +160,8 @@ void OH_HashMapDestory(HashMapHandle handle)
 HashNode *OH_HashMapFind(HashMapHandle handle,
     int hashCode, const void *key, HashKeyCompare keyCompare)
 {
-    INIT_ERROR_CHECK(handle != NULL && key != NULL, return NULL, "Invalid param");
-    INIT_ERROR_CHECK(handle != NULL && keyCompare != NULL, return NULL, "Invalid param");
+    INIT_ERROR_CHECK(handle != NULL, return NULL, "Invalid hash handle");
+    INIT_ERROR_CHECK(key != NULL && keyCompare != NULL, return NULL, "Invalid hash key");
     HashTab *tab = (HashTab *)handle;
     INIT_ERROR_CHECK(hashCode < tab->maxBucket, return NULL,
         "Invalid hashcode %d %d", tab->maxBucket, hashCode);
@@ -171,7 +171,7 @@ HashNode *OH_HashMapFind(HashMapHandle handle,
 void OH_HashMapTraverse(HashMapHandle handle, void (*hashNodeTraverse)(const HashNode *node, const void *context),
     const void *context)
 {
-    INIT_ERROR_CHECK(handle != NULL && hashNodeTraverse != NULL, return, "Invalid param");
+    INIT_ERROR_CHECK(handle != NULL && hashNodeTraverse != NULL, return, "Invalid hash handle");
     HashTab *tab = (HashTab *)handle;
     for (int i = 0; i < tab->maxBucket; i++) {
         HashNode *node = tab->buckets[i];
@@ -185,7 +185,7 @@ void OH_HashMapTraverse(HashMapHandle handle, void (*hashNodeTraverse)(const Has
 
 int OH_HashMapIsEmpty(HashMapHandle handle)
 {
-    INIT_ERROR_CHECK(handle != NULL, return 1, "Invalid param");
+    INIT_ERROR_CHECK(handle != NULL, return 1, "Invalid hash handle");
     HashTab *tab = (HashTab *)handle;
     for (int i = 0; i < tab->maxBucket; i++) {
         HashNode *node = tab->buckets[i];

services/utils/init_utils.c

@@ -162,6 +162,7 @@ char *ReadFileToBuf(const char *configFile)
 
 void CloseStdio(void)
 {
+#ifndef STARTUP_INIT_TEST
 #ifndef __LITEOS_M__
     int fd = open("/dev/null", O_RDWR | O_CLOEXEC);
     if (fd < 0) {
@@ -172,6 +173,7 @@ void CloseStdio(void)
     dup2(fd, STDERR_HANDLE);
     close(fd);
 #endif
+#endif
 }
 
 char *ReadFileData(const char *fileName)

test/unittest/BUILD.gn

@@ -19,6 +19,8 @@ config("utest_config") {
   cflags = [
     "-Wno-implicit-fallthrough",
     "-Wno-unused-function",
+    "-Dprivate=public",
+    "-Dprotected=public",
   ]
   cflags_cc = [
     "-Wno-implicit-fallthrough",

ueventd/include/ueventd.h

@@ -16,6 +16,11 @@
 #ifndef BASE_STARTUP_INITLITE_UEVENTD_H
 #define BASE_STARTUP_INITLITE_UEVENTD_H
 #include <unistd.h>
+#ifdef __cplusplus
+#if __cplusplus
+extern "C" {
+#endif
+#endif
 
 // Refer to linux kernel kobject.h
 typedef enum ACTION {
@@ -71,4 +76,9 @@ void ParseUeventMessage(const char *buffer, ssize_t length, struct Uevent *ueven
 void RetriggerUevent(int sockFd, char **devices, int num);
 void ProcessUevent(int sockFd, char **devices, int num);
 
+#ifdef __cplusplus
+#if __cplusplus
+}
+#endif
+#endif
 #endif // BASE_STARTUP_INITLITE_UEVENTD_H

ueventd/include/ueventd_device_handler.h

@@ -16,7 +16,18 @@
 #ifndef BASE_STARTUP_INITLITE_UEVENTD_DEVICE_HANDLER_H
 #define BASE_STARTUP_INITLITE_UEVENTD_DEVICE_HANDLER_H
 #include "ueventd.h"
+#ifdef __cplusplus
+#if __cplusplus
+extern "C" {
+#endif
+#endif
+
 void HandleBlockDeviceEvent(const struct Uevent *uevent);
 void HandleOtherDeviceEvent(const struct Uevent *uevent);
 
+#ifdef __cplusplus
+#if __cplusplus
+}
+#endif
+#endif
 #endif // BASE_STARTUP_INITLITE_UEVENTD_DEVICE_HANDLER_H

ueventd/include/ueventd_socket.h

@@ -16,6 +16,18 @@
 #ifndef BASE_STARTUP_INITLITE_UEVENTD_SOCKET_H
 #define BASE_STARTUP_INITLITE_UEVENTD_SOCKET_H
 #include <sys/types.h>
+#include <unistd.h>
+#ifdef __cplusplus
+#if __cplusplus
+extern "C" {
+#endif
+#endif
+
 int UeventdSocketInit(void);
 ssize_t ReadUeventMessage(int sockFd, char *buffer, size_t length);
+#ifdef __cplusplus
+#if __cplusplus
+}
+#endif
+#endif
 #endif // BASE_STARTUP_INITLITE_LIST_H

ueventd/ueventd.c

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

ueventd/ueventd_device_handler.c

@@ -428,7 +428,7 @@ void HandleBlockDeviceEvent(const struct Uevent *uevent)
     }
 
     if (strcmp(uevent->subsystem, "block") != 0) {
-        INIT_LOGE("Unexpceted uevent subsystem \" %s \" received in block device handler", uevent->subsystem);
+        INIT_LOGE("Unexpected uevent subsystem \" %s \" received in block device handler", uevent->subsystem);
         return;
     }
 
@@ -475,7 +475,8 @@ void HandleOtherDeviceEvent(const struct Uevent *uevent)
 
     char deviceNode[DEVICE_FILE_SIZE] = {};
     char sysPath[SYSPATH_SIZE] = {};
-    if (strncpy_s(sysPath, SYSPATH_SIZE - 1, uevent->syspath, strlen(uevent->syspath) != EOK)) {
+    if ((uevent->syspath == NULL) ||
+        strncpy_s(sysPath, SYSPATH_SIZE - 1, uevent->syspath, strlen(uevent->syspath)) != EOK) {
         INIT_LOGE("Failed to copy sys path");
         return;
     }

ueventd/ueventd_socket.c

@@ -50,8 +50,10 @@ int UeventdSocketInit(void)
 
     if (bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
         INIT_LOGE("Bind socket failed, err = %d", errno);
+#ifndef STARTUP_INIT_TEST
         close(sockfd);
         return -1;
+#endif
     }
     return sockfd;
 }