init: fix bugs

Signed-off-by: Nsun_fan <sun_fan1@hoperun.com>

interfaces/innerkits/fs_manager/fstab.c

@@ -55,7 +55,6 @@ unsigned int ConvertFlags(char *flagBuffer)
         // No valid flags.
         return 0;
     }
-    printf("[fs_manager][debug], fstab flags string: %s\n", flagBuffer);
     int flagCount = 0;
     unsigned int flags = 0;
     const int maxCount = 3;
@@ -66,7 +65,6 @@ unsigned int ConvertFlags(char *flagBuffer)
 
     for (size_t i = 0; i < ARRAY_LENGTH(fsFlags); i++) {
         for (int j = 0; j < flagCount; j++) {
-            printf("[fs_manager][debug], flag: %s\n", vector[j]);
             if (strcmp(fsFlags[i].name, vector[j]) == 0) {
                 flags |= fsFlags[i].flags;
             }
@@ -211,6 +209,8 @@ Fstab *ReadFstabFromFile(const char *file, bool procMounts)
 
     if ((fstab = (Fstab *)calloc(1, sizeof(Fstab))) == NULL) {
         printf("[fs_manager] Allocate memory for FS table failed, err = %d\n", errno);
+        fclose(fp);
+        fp = NULL;
         return NULL;
     }
 
@@ -238,13 +238,15 @@ Fstab *ReadFstabFromFile(const char *file, bool procMounts)
             }
             // If one line in fstab file parsed with a failure. just give a warning
             // and skip it.
-             printf("[fs_manager][warning] Cannot parse file \" %s \" at line %u. skip it\n", file, ln);
+            printf("[fs_manager][warning] Cannot parse file \" %s \" at line %u. skip it\n", file, ln);
             continue;
         }
     }
     if (line != NULL) {
         free(line);
     }
+    fclose(fp);
+    fp = NULL;
     return fstab;
 }
 

services/etc/init.cfg

@@ -2,7 +2,6 @@
     "import" : [
             "/etc/init.usb.cfg",
             "/etc/init.usb.configfs.cfg",
-            "/etc/init.usb.cfg",
             "/vendor/etc/init.${ohos.boot.hardware}.cfg"
     ],
     "jobs" : [{

services/init/init_common_cmds.c

@@ -653,8 +653,8 @@ const char *GetCmdKey(int index)
     }
     int number = 0;
     const struct CmdTable *cmds = GetCmdTable(&number);
-    if (index < number) {
-        return cmds[index].name;
+    if (index < (cmdCnt + number)) {
+        return cmds[index - cmdCnt].name;
     }
     return NULL;
 }

services/init/standard/switch_root.c

@@ -71,6 +71,31 @@ static void FreeOldRoot(DIR *dir, dev_t dev)
     }
 }
 
+// For sub mountpoint under /dev, /sys, /proc
+// There is no need to move them individually
+// We will find a better solution to take care of
+// all sub mount tree in the future.
+static bool UnderBasicMountPoint(const char *path)
+{
+    if (path == NULL || *path == '\0') {
+        return false;
+    }
+
+    size_t pathSize = strlen(path);
+    if (strncmp(path, "/dev", strlen("/dev")) == 0 && pathSize > strlen("/dev")) {
+        return true;
+    }
+
+    if (strncmp(path, "/sys", strlen("/sys")) == 0 && pathSize > strlen("/sys")) {
+        return true;
+    }
+
+    if (strncmp(path, "/proc", strlen("/proc")) == 0 && pathSize > strlen("/proc")) {
+        return true;
+    }
+    return false;
+}
+
 static int MountToNewTarget(const char *target)
 {
     if (target == NULL || *target == '\0') {
@@ -94,12 +119,15 @@ static int MountToNewTarget(const char *target)
             // Just ignore this one or return error?
             continue;
         }
-        INIT_LOGI("new mount point is: %s", newMountPoint);
-        if (mount(mountPoint, newMountPoint, NULL, MS_MOVE, NULL) < 0) {
-            INIT_LOGE("Failed to mount moving %s to %s, err = %d", mountPoint, newMountPoint, errno);
-            // If one mount entry cannot move to new mountpoint, umount it.
-            umount2(mountPoint, MNT_FORCE);
-            continue;
+        INIT_LOGD("new mount point is: %s", newMountPoint);
+        if (!UnderBasicMountPoint(mountPoint)) {
+            INIT_LOGD("Move mount %s to %s", mountPoint, newMountPoint);
+            if (mount(mountPoint, newMountPoint, NULL, MS_MOVE, NULL) < 0) {
+                INIT_LOGE("Failed to mount moving %s to %s, err = %d", mountPoint, newMountPoint, errno);
+                // If one mount entry cannot move to new mountpoint, umount it.
+                umount2(mountPoint, MNT_FORCE);
+                continue;
+            }
         }
     }
     ReleaseFstab(fstab);

services/param/adapter/param_libuvadp.c

@@ -15,7 +15,6 @@
 #include "param_libuvadp.h"
 #include <sys/wait.h>
 
-static LibuvWorkSpace libuv = { NULL };
 static const uint32_t RECV_BUFFER_MAX = 5 * 1024;
 
 static LibuvBaseTask *CreateLibuvTask(uint32_t size, uint32_t flags, uint16_t userDataSize, TaskClose close)
@@ -183,16 +182,16 @@ int ParamStreamCreate(ParamTaskPtr *stream, ParamTaskPtr server, const ParamStre
             return -1, "Failed to uv_pipe_init %d", ret);
         pipe->data = &pipeServer->server;
         PARAM_LOGD("OnConnection pipeServer: %p pipe %p", pipeServer, &pipeServer->server);
-        if ((info->flags & WORKER_TYPE_TEST) != WORKER_TYPE_TEST) {
-            ret = uv_accept((uv_stream_t *)&pipeServer->server.pipe, (uv_stream_t *)pipe);
-            PARAM_CHECK(ret == 0, uv_close((uv_handle_t *)pipe, NULL);
-                free(client);
-                return -1, "Failed to uv_accept %d", ret);
-            ret = uv_read_start((uv_stream_t *)pipe, OnReceiveAlloc, OnReceiveRequest);
-            PARAM_CHECK(ret == 0, uv_close((uv_handle_t *)pipe, NULL);
-                free(client);
-                return -1, "Failed to uv_read_start %d", ret);
-        }
+#ifndef STARTUP_INIT_TEST
+        ret = uv_accept((uv_stream_t *)&pipeServer->server.pipe, (uv_stream_t *)pipe);
+        PARAM_CHECK(ret == 0, uv_close((uv_handle_t *)pipe, NULL);
+            free(client);
+            return -1, "Failed to uv_accept %d", ret);
+        ret = uv_read_start((uv_stream_t *)pipe, OnReceiveAlloc, OnReceiveRequest);
+        PARAM_CHECK(ret == 0, uv_close((uv_handle_t *)pipe, NULL);
+            free(client);
+            return -1, "Failed to uv_read_start %d", ret);
+#endif
     }
     client->recvMessage = info->recvMessage;
     *stream = &client->base.worker;
@@ -216,17 +215,17 @@ int ParamTaskSendMsg(const ParamTaskPtr stream, const ParamMessage *msg)
 {
     PARAM_CHECK(stream != NULL && msg != NULL, LibuvFreeMsg(stream, msg);
         return -1, "Invalid stream");
-    LibuvStreamTask *worker = (LibuvStreamTask *)stream;
     if ((stream->flags & WORKER_TYPE_MSG) != WORKER_TYPE_MSG) {
         LibuvFreeMsg(stream, msg);
         return -1;
     }
-    if ((stream->flags & WORKER_TYPE_TEST) != WORKER_TYPE_TEST) {
-        uv_buf_t buf = uv_buf_init((char *)msg, msg->msgSize);
-        int ret = uv_write(&worker->writer, (uv_stream_t *)&worker->stream.pipe, &buf, 1, OnWriteResponse);
-        PARAM_CHECK(ret >= 0, LibuvFreeMsg(stream, msg);
-            return -1, "Failed to uv_write2 ret %s", uv_strerror(ret));
-    }
+#ifndef STARTUP_INIT_TEST
+    LibuvStreamTask *worker = (LibuvStreamTask *)stream;
+    uv_buf_t buf = uv_buf_init((char *)msg, msg->msgSize);
+    int ret = uv_write(&worker->writer, (uv_stream_t *)&worker->stream.pipe, &buf, 1, OnWriteResponse);
+    PARAM_CHECK(ret >= 0, LibuvFreeMsg(stream, msg);
+        return -1, "Failed to uv_write2 ret %s", uv_strerror(ret));
+#endif
     LibuvFreeMsg(stream, msg);
     return 0;
 }
@@ -315,35 +314,11 @@ int ParamTimerStart(ParamTaskPtr timer, uint64_t timeout, uint64_t repeat)
     return -1;
 }
 
-static void SignalHandler(uv_signal_t *handle, int signum)
-{
-    UNUSED(handle);
-    if (signum != SIGCHLD) {
-        return;
-    }
-    pid_t pid = 0;
-    int procStat = 0;
-    while (1) {
-        pid = waitpid(-1, &procStat, WNOHANG);
-        if (pid <= 0) {
-            break;
-        }
-    }
-    if (libuv.pidDeleteProcess != NULL) {
-        libuv.pidDeleteProcess(pid);
-    }
-}
-
-int ParamServiceStart(ProcessPidDelete pidDelete)
+int ParamServiceStart()
 {
     if (uv_default_loop() == NULL) {
         return -1;
     }
-    libuv.pidDeleteProcess = pidDelete;
-    uv_signal_t sigchldHandler;
-    int ret = uv_signal_init(uv_default_loop(), &sigchldHandler);
-    int ret1 = uv_signal_start(&sigchldHandler, SignalHandler, SIGCHLD);
-    PARAM_CHECK(ret == 0 && ret1 == 0, return -1, "Failed to process signal ");
     uv_run(uv_default_loop(), UV_RUN_DEFAULT);
     return 0;
 }

services/param/adapter/param_libuvadp.h

@@ -21,10 +21,6 @@
 #include "param_utils.h"
 #include "uv.h"
 
-typedef struct {
-    ProcessPidDelete pidDeleteProcess;
-} LibuvWorkSpace;
-
 typedef struct {
     ParamTask worker;
     TaskClose close;

services/param/cmd/param_cmd.c

@@ -52,10 +52,8 @@ static void ExeuteCmdParamGet(int argc, char *argv[], int start)
 {
     uint32_t size = PARAM_CONST_VALUE_LEN_MAX + PARAM_NAME_LEN_MAX + 1 + 1;
     char *buffer = (char *)calloc(1, size);
-    if (buffer == NULL) {
-        printf("Get parameterfail\n");
-        return;
-    }
+    PARAM_CHECK(buffer != NULL, return, "Failed to get parameter");
+
     if (argc == start) {
         SystemTraversalParameter(ShowParam, (void *)buffer);
     } else {

services/param/include/param_message.h

@@ -43,8 +43,6 @@ extern "C" {
 #define WORKER_TYPE_SERVER 0x20
 #define WORKER_TYPE_CLIENT 0x40
 
-#define WORKER_TYPE_TEST 0x01000000
-
 typedef enum {
     MSG_SET_PARAM,
     MSG_WAIT_PARAM,
@@ -92,7 +90,6 @@ typedef int (*RecvMessage)(const ParamTaskPtr stream, const ParamMessage *msg);
 typedef void (*TimerProcess)(const ParamTaskPtr stream, void *context);
 typedef void (*EventProcess)(uint64_t eventId, const char *context, uint32_t size);
 typedef void (*TaskClose)(const ParamTaskPtr stream);
-typedef void (*ProcessPidDelete)(pid_t pid);
 
 typedef struct ParamTask_ {
     uint32_t flags;
@@ -107,7 +104,7 @@ typedef struct {
 } ParamStreamInfo;
 
 int ParamServiceStop(void);
-int ParamServiceStart(ProcessPidDelete pidDelete);
+int ParamServiceStart();
 
 int ParamTaskClose(ParamTaskPtr stream);
 int ParamServerCreate(ParamTaskPtr *server, const ParamStreamInfo *info);

services/param/include/param_persist.h

@@ -40,14 +40,14 @@ typedef struct {
 
 #ifdef PARAM_SUPPORT_SAVE_PERSIST
 int RegisterPersistParamOps(PersistParamOps *ops);
-#ifdef STARTUP_INIT_TEST
+#endif
+
+#ifndef STARTUP_INIT_TEST
 #define PARAM_MUST_SAVE_PARAM_DIFF 10 // 10s
 #else
 #define PARAM_MUST_SAVE_PARAM_DIFF 1
 #endif
-#else
-#define PARAM_MUST_SAVE_PARAM_DIFF UINT32_MAX
-#endif
+
 #ifdef __cplusplus
 #if __cplusplus
 }

services/param/include/trigger_manager.h

@@ -45,6 +45,7 @@ extern "C" {
 
 #define CMD_INDEX_FOR_PARA_WAIT 0xfffE
 #define CMD_INDEX_FOR_PARA_WATCH 0xffff
+#define CMD_INDEX_FOR_PARA_TEST 0x10000
 
 #define TRIGGER_IN_QUEUE(trigger) (((trigger)->flags & TRIGGER_FLAGS_QUEUE) == TRIGGER_FLAGS_QUEUE)
 #define TRIGGER_SET_FLAG(trigger, flag) ((trigger)->flags |= (flag))

services/param/service/param_persist.c

@@ -161,6 +161,7 @@ int WritePersistParam(ParamWorkSpace *workSpace, const char *name, const char *v
     time_t currTimer;
     (void)time(&currTimer);
     uint32_t diff = (uint32_t)difftime(currTimer, g_persistWorkSpace.lastSaveTimer);
+    PARAM_LOGD("WritePersistParam name %s  %d ", name, diff);
     if (diff > PARAM_MUST_SAVE_PARAM_DIFF) {
         if (g_persistWorkSpace.saveTimer != NULL) {
             ParamTaskClose(g_persistWorkSpace.saveTimer);

services/param/service/param_service.c

@@ -36,9 +36,6 @@ static ParamWorkSpace g_paramWorkSpace = { 0, {}, NULL, {}, NULL, NULL };
 static void OnClose(ParamTaskPtr client)
 {
     ParamWatcher *watcher = (ParamWatcher *)ParamGetTaskUserData(client);
-    if (watcher == GetParamWatcher(NULL)) {
-        return;
-    }
     ClearWatcherTrigger(watcher);
     ListRemove(&watcher->node);
 }
@@ -238,6 +235,12 @@ static int SystemSetParam(const char *name, const char *value, const ParamSecuri
         PARAM_CHECK(ret == 0, return ret, "Failed to set persist param name %s", name);
         CheckAndSendTrigger(&g_paramWorkSpace, dataIndex, name, value);
     }
+
+    // watcher stoped
+    if (strcmp(name, "init.svc.param_watcher") == 0 && strcmp(value, "stopped") == 0) {
+        ParamWatcher *watcher = GetParamWatcher(NULL);
+        ClearWatcherTrigger(watcher);
+    }
     return ret;
 }
 
@@ -695,19 +698,15 @@ void InitParamService(void)
     LoadParamFromCmdLine();
 }
 
-static void OnPidDelete(pid_t pid)
-{
-    UNUSED(pid);
-}
-
 int StartParamService(void)
 {
-    return ParamServiceStart(OnPidDelete);
+    return ParamServiceStart();
 }
 
 void StopParamService(void)
 {
     PARAM_LOGI("StopParamService.");
+    ClosePersistParamWorkSpace();
     CloseParamWorkSpace(&g_paramWorkSpace);
     CloseTriggerWorkSpace();
     ParamTaskClose(g_paramWorkSpace.serverTask);

services/param/trigger/trigger_manager.c

@@ -50,7 +50,8 @@ int AddCommand(TriggerNode *trigger, uint32_t cmdKeyIndex, const char *content)
         trigger->firstCmd = node;
         trigger->lastCmd = node;
     } else {
-        PARAM_CHECK(trigger->lastCmd != NULL, return 0, "Invalid last cmd");
+        PARAM_CHECK(trigger->lastCmd != NULL, free(node);
+            return 0, "Invalid last cmd");
         trigger->lastCmd->next = node;
         trigger->lastCmd = node;
     }

services/param/watcher/agent/watcher.cpp

@@ -12,7 +12,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 #include "watcher.h"
 
 #include "iservice_registry.h"

services/param/watcher/agent/watcher_manager_kits.cpp

@@ -129,6 +129,7 @@ int32_t WatcherManagerKits::DelWatcher(const std::string &keyPrefix)
 
 void WatcherManagerKits::ParamWatcher::OnParamerterChange(const std::string &name, const std::string &value)
 {
+    Watcher::OnParamerterChange(name, value);
     WATCHER_LOGD("OnParamerterChange name %s value %s", name.c_str(), value.c_str());
     if (callback_ != nullptr) {
         callback_(name.c_str(), value.c_str(), context_);

services/param/watcher/agent/watcher_manager_kits.h

@@ -36,7 +36,9 @@ public:
     static WatcherManagerKits &GetInstance();
     int32_t AddWatcher(const std::string &keyPrefix, ParameterChangePtr callback, void *context);
     int32_t DelWatcher(const std::string &keyPrefix);
+#ifndef STARTUP_INIT_TEST
 private:
+#endif
     class ParamWatcher final : public Watcher {
     public:
         ParamWatcher(const std::string &key, ParameterChangePtr callback, void *context)
@@ -60,6 +62,8 @@ private:
         ParameterChangePtr callback_ { nullptr };
         void *context_ { nullptr };
     };
+    using ParamWatcherKitPtr = sptr<WatcherManagerKits::ParamWatcher>;
+    ParamWatcherKitPtr GetParamWatcher(const std::string &keyPrefix);
 
     // For death event procession
     class DeathRecipient final : public IRemoteObject::DeathRecipient {
@@ -69,10 +73,9 @@ private:
         DISALLOW_COPY_AND_MOVE(DeathRecipient);
         void OnRemoteDied(const wptr<IRemoteObject> &remote) final;
     };
+    sptr<IRemoteObject::DeathRecipient> GetDeathRecipient() { return deathRecipient_; }
 
 private:
-    using ParamWatcherKitPtr = sptr<WatcherManagerKits::ParamWatcher>;
-    ParamWatcherKitPtr GetParamWatcher(const std::string &keyPrefix);
     void SetParamWatcher(const std::string &keyPrefix, ParamWatcherKitPtr watcher);
     void ResetService(const wptr<IRemoteObject> &remote);
     sptr<IWatcherManager> GetService();

services/param/watcher/proxy/watcher_manager.cpp

@@ -58,10 +58,8 @@ uint32_t WatcherManager::AddWatcher(const std::string &keyPrefix, const sptr<IWa
 int32_t WatcherManager::DelWatcher(const std::string &keyPrefix, uint32_t watcherId)
 {
     auto group = GetWatcherGroup(keyPrefix);
-    if (group == nullptr) {
-        WATCHER_LOGE("DelWatcher can not find group %s", keyPrefix.c_str());
-        return 0;
-    }
+    WATCHER_CHECK(group != nullptr, return 0, "DelWatcher can not find group %s", keyPrefix.c_str());
+
     group->DelWatcher(watcherId);
     if (group->Emptry()) {
         SendMessage(group, MSG_DEL_WATCHER);
@@ -79,18 +77,14 @@ int WatcherManager::SendMessage(WatcherGroupPtr group, int type)
     request->msgSize = sizeof(ParamMessage);
 
     WATCHER_LOGD("SendMessage %s", group->GetKeyPrefix().c_str());
+    int ret = PARAM_CODE_ERROR;
     int fd = GetServerFd(false);
     if (fd != INVALID_SOCKET) {
         ssize_t sendLen = send(serverFd_, (char *)request, request->msgSize, 0);
-        if (sendLen > 0) {
-            PARAM_LOGD("SendMessage key: %s %d success", group->GetKeyPrefix().c_str(), type);
-        } else {
-            PARAM_LOGD("SendMessage key: %s %d fail", group->GetKeyPrefix().c_str(), type);
-        }
-    } else {
-        PARAM_LOGD("SendMessage key: %s %d fail", group->GetKeyPrefix().c_str(), type);
+        ret = (sendLen > 0) ? 0 : PARAM_CODE_ERROR;
     }
     free(request);
+    PARAM_CHECK(ret == 0, return ret, "SendMessage key: %s %d fail", group->GetKeyPrefix().c_str(), type);
     return 0;
 }
 
@@ -166,14 +160,6 @@ void WatcherManager::WatcherGroup::DelWatcher(uint32_t watcherId)
     }
 }
 
-WatcherManager::ParamWatcherPtr WatcherManager::WatcherGroup::GetWatcher(uint32_t watcherId)
-{
-    if (watchers_.find(watcherId) != watchers_.end()) {
-        return watchers_[watcherId];
-    }
-    return nullptr;
-}
-
 void WatcherManager::WatcherGroup::ProcessParameterChange(const std::string &name, const std::string &value)
 {
     // walk watcher

services/param/watcher/proxy/watcher_manager.h

@@ -24,6 +24,7 @@
 #include "iremote_stub.h"
 #include "iwatcher.h"
 #include "message_parcel.h"
+#include "param_utils.h"
 #include "parcel.h"
 #include "system_ability.h"
 #include "watcher_manager_stub.h"
@@ -52,7 +53,9 @@ public:
         }
         void ProcessParameterChange(const std::string &name, const std::string &value)
         {
+#ifndef STARTUP_INIT_TEST
             watcher_->OnParamerterChange(name, value);
+#endif
         }
     private:
         uint32_t watcherId_ = { 0 };
@@ -67,7 +70,6 @@ public:
         void AddWatcher(const ParamWatcherPtr &watcher);
         void DelWatcher(uint32_t watcherId);
         void ProcessParameterChange(const std::string &name, const std::string &value);
-        ParamWatcherPtr GetWatcher(uint32_t watcherId);
 
         const std::string GetKeyPrefix()
         {
@@ -90,19 +92,23 @@ public:
 
     uint32_t AddWatcher(const std::string &keyPrefix, const sptr<IWatcher> &watcher) override;
     int32_t DelWatcher(const std::string &keyPrefix, uint32_t watcherId) override;
-    void StopLoop();
+#ifndef STARTUP_INIT_TEST
 protected:
+#endif
     void OnStart() override;
     void OnStop() override;
+#ifndef STARTUP_INIT_TEST
 private:
+#endif
+    void ProcessWatcherMessage(const std::vector<char> &buffer, uint32_t dataSize);
     WatcherGroupPtr GetWatcherGroup(uint32_t groupId);
     WatcherGroupPtr GetWatcherGroup(const std::string &keyPrefix);
     void AddWatcherGroup(const std::string &keyPrefix, WatcherGroupPtr group);
     void DelWatcherGroup(WatcherGroupPtr group);
     void RunLoop();
     void StartLoop();
+    void StopLoop();
     void SendLocalChange(const std::string &keyPrefix, ParamWatcherPtr watcher);
-    void ProcessWatcherMessage(const std::vector<char> &buffer, uint32_t dataSize);
     int SendMessage(WatcherGroupPtr group, int type);
     int GetServerFd(bool retry);
 private:

services/test/unittest/BUILD.gn

@@ -71,6 +71,9 @@ ohos_unittest("init_ut") {
     "//base/startup/init_lite/services/param/watcher/proxy/watcher_proxy.cpp",
     "//base/startup/init_lite/services/utils/init_utils.c",
     "//base/startup/init_lite/services/utils/list.c",
+    "//base/startup/init_lite/services/init/standard/init_mount.c",
+    "//base/startup/init_lite/interfaces/innerkits/fs_manager/fstab.c",
+    "//base/startup/init_lite/interfaces/innerkits/fs_manager/fstab_mount.c",
   ]
 
   sources += [
@@ -88,6 +91,7 @@ ohos_unittest("init_ut") {
   configs = [ "//base/startup/init_lite/services/test/unittest:utest_config" ]
 
   include_dirs = [
+    "//base/startup/init_lite/interfaces/innerkits/include",
     "//base/startup/init_lite/services/include",
     "//base/startup/init_lite/services/init/include",
     "//base/startup/init_lite/services/include/param",

services/test/unittest/param/client_unittest.cpp

@@ -147,10 +147,18 @@ static void TestCmd()
     const char *argForSet[] = { "param", "set", "aaaa", "2222" };
     RunParamCommand(ARRAY_LENGTH(argForSet), const_cast<char **>(argForSet));
 
+    // set fail
+    const char *argForSet1[] = { "param", "set", "aaaa&&&&&&&&&####", "2222" };
+    RunParamCommand(ARRAY_LENGTH(argForSet1), const_cast<char **>(argForSet1));
+
     // get
     const char *argForGet[] = { "param", "get", "aaaa" };
     RunParamCommand(ARRAY_LENGTH(argForGet), const_cast<char **>(argForGet));
 
+    // get not exit
+    const char *argForGet1[] = { "param", "get", "aaaaaaaa" };
+    RunParamCommand(ARRAY_LENGTH(argForGet1), const_cast<char **>(argForGet1));
+
     // get all
     const char *argForGet2[] = { "param", "get" };
     RunParamCommand(ARRAY_LENGTH(argForGet2), const_cast<char **>(argForGet2));
@@ -174,10 +182,10 @@ static void TestCmd()
     const char *argForSet7[] = { "paramget", "aaaa" };
     RunParamCommand(ARRAY_LENGTH(argForSet7), const_cast<char **>(argForSet7));
 
-    const char *argForSet8[] = { "param dump", "verbose" };
+    const char *argForSet8[] = { "param", "dump", "verbose" };
     RunParamCommand(ARRAY_LENGTH(argForSet8), const_cast<char **>(argForSet8));
 
-    const char *argForSet9[] = { "param wait", "test.wait.001", "1" };
+    const char *argForSet9[] = { "param", "wait", "test.wait.001", "*", "1" };
     RunParamCommand(ARRAY_LENGTH(argForSet9), const_cast<char **>(argForSet9));
 }
 

services/test/unittest/param/param_unittest.cpp

@@ -280,9 +280,10 @@ public:
         sleep(1);
         SystemWriteParam("persist.111.bbbb.cccc.dddd.1110", "1108");
         SystemWriteParam("persist.111.bbbb.cccc.dddd.1111", "1108");
-        TimerCallbackForSave(NULL, NULL);
-        // 加载
-        LoadPersistParam(GetParamWorkSpace());
+        if (GetParamWorkSpace() != nullptr) {
+            TimerCallbackForSave(nullptr, &(GetParamWorkSpace()->paramSpace));
+        }
+        LoadPersistParams();
         return 0;
     }
 
@@ -318,7 +319,7 @@ public:
         }
 
         // 创建stream task
-        server->incomingConnect((ParamTaskPtr)server, WORKER_TYPE_TEST);
+        server->incomingConnect((ParamTaskPtr)server, 0);
         ParamWatcher *watcher = GetNextParamWatcher(GetTriggerWorkSpace(), nullptr);
         return watcher != nullptr ? watcher->stream : nullptr;
     }
@@ -444,6 +445,7 @@ public:
         ClearWatcherTrigger(watcher);
         ParamTaskClose(g_worker);
         g_worker = nullptr;
+        SystemWriteParam("init.svc.param_watcher", "stopped");
         return 0;
     }
 

services/test/unittest/param/trigger_unittest.cpp

@@ -80,7 +80,7 @@ public:
         TestClient(0);
         ParamTaskPtr timer = nullptr;
         ParamTimerCreate(&timer, TimerCallback, nullptr);
-        ParamTimerStart(timer, 1000, g_maxCount);
+        ParamTimerStart(timer, 500, g_maxCount); // 500ms
         StartParamService();
         return 0;
     }

services/test/unittest/param/watcher_agent_unittest.cpp

@@ -12,19 +12,26 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
 #include <cstdio>
 #include <cstring>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
 
+#include "if_system_ability_manager.h"
+#include "iservice_registry.h"
 #include "iwatcher.h"
 #include "iwatcher_manager.h"
+#include "message_parcel.h"
 #include "param_utils.h"
 #include "sys_param.h"
+#include "system_ability_definition.h"
+#include "watcher.h"
 #include "watcher_manager_kits.h"
 
 using namespace testing::ext;
 using namespace std;
+using namespace OHOS;
+using namespace OHOS::init_param;
 
 void TestParameterChange(const char *key, const char *value, void *context)
 {
@@ -61,6 +68,9 @@ public:
         EXPECT_EQ(ret, 0);
         ret = SystemWatchParameter("test.permission.watcher.test1*", nullptr, nullptr);
         EXPECT_EQ(ret, 0);
+        ret = SystemWatchParameter("test.permission.watcher.test2", nullptr, nullptr);
+        EXPECT_EQ(ret, 0);
+
         // 非法
         ret = SystemWatchParameter("test.permission.watcher.tes^^^^t1*", nullptr, nullptr);
         EXPECT_NE(ret, 0);
@@ -70,8 +80,35 @@ public:
         return 0;
     }
 
-    int TestRecvMessage()
+    int TestRecvMessage(const std::string &name)
+    {
+        MessageParcel data;
+        MessageParcel reply;
+        MessageOption option;
+        data.WriteString(name);
+        data.WriteString("watcherId");
+
+        int ret = SystemWatchParameter(name.c_str(), TestParameterChange, nullptr);
+        EXPECT_EQ(ret, 0);
+        OHOS::init_param::WatcherManagerKits &instance = OHOS::init_param::WatcherManagerKits::GetInstance();
+        OHOS::init_param::WatcherManagerKits::ParamWatcherKitPtr watcher = instance.GetParamWatcher(name);
+        if (watcher != nullptr) {
+            watcher->OnRemoteRequest(IWatcher::PARAM_CHANGE, data, reply, option);
+            watcher->OnRemoteRequest(IWatcher::PARAM_CHANGE + 1, data, reply, option);
+        }
+        return 0;
+    }
+
+    int TestResetService()
     {
+        sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        WATCHER_CHECK(samgr != nullptr, return -1, "Get samgr failed");
+        sptr<IRemoteObject> object = samgr->GetSystemAbility(PARAM_WATCHER_DISTRIBUTED_SERVICE_ID);
+        WATCHER_CHECK(object != nullptr, return -1, "Get watcher manager object from samgr failed");
+        OHOS::init_param::WatcherManagerKits &instance = OHOS::init_param::WatcherManagerKits::GetInstance();
+        if (instance.GetDeathRecipient() != nullptr) {
+            instance.GetDeathRecipient()->OnRemoteDied(object);
+        }
         return 0;
     }
 };
@@ -82,8 +119,20 @@ HWTEST_F(WatcherAgentTest, TestAddWatcher, TestSize.Level1)
     test.TestAddWatcher();
 }
 
+HWTEST_F(WatcherAgentTest, TestRecvMessage, TestSize.Level1)
+{
+    WatcherAgentTest test;
+    test.TestRecvMessage("test.permission.watcher.agent.test1");
+}
+
 HWTEST_F(WatcherAgentTest, TestDelWatcher, TestSize.Level1)
 {
     WatcherAgentTest test;
     test.TestDelWatcher();
+}
+
+HWTEST_F(WatcherAgentTest, TestResetService, TestSize.Level1)
+{
+    WatcherAgentTest test;
+    test.TestResetService();
 }
\ No newline at end of file

services/test/unittest/param/watcher_proxy_unittest.cpp

@@ -12,19 +12,26 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
 #include <cstdio>
 #include <cstring>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
 
+#include "if_system_ability_manager.h"
 #include "init_unittest.h"
+#include "iservice_registry.h"
+#include "iwatcher.h"
 #include "iwatcher_manager.h"
 #include "message_parcel.h"
+#include "param_message.h"
+#include "param_request.h"
 #include "param_utils.h"
 #include "parcel.h"
 #include "securec.h"
+#include "system_ability_definition.h"
 #include "watcher.h"
 #include "watcher_manager.h"
+#include "watcher_proxy.h"
 #include "watcher_utils.h"
 
 using namespace testing::ext;
@@ -64,13 +71,17 @@ public:
         MessageOption option;
 
         data.WriteString(keyPrefix);
-        std::shared_ptr<TestWatcher> watcher = std::make_shared<TestWatcher>();
+        sptr<IWatcher> watcher = new TestWatcher();
+        // std::shared_ptr<TestWatcher> watcher = std::make_shared<TestWatcher>();
         bool ret = data.WriteRemoteObject(watcher->AsObject());
         WATCHER_CHECK(ret, return 0, "Can not get remote");
         watcherManager->OnRemoteRequest(IWatcherManager::ADD_WATCHER, data, reply, option);
         watcherId = reply.ReadUint32();
         EXPECT_NE(watcherId, 0);
         printf("TestAddWatcher %s watcherId %d %p \n", keyPrefix.c_str(), watcherId, watcherManager);
+
+        EXPECT_EQ(watcherManager->GetWatcherGroup(1000) != NULL, 0); // test group id
+        EXPECT_EQ(watcherManager->GetWatcherGroup("TestAddWatcher") != NULL, 0); // test key not exist
         return 0;
     }
 
@@ -85,11 +96,47 @@ public:
         data.WriteUint32(watcherId);
         watcherManager->OnRemoteRequest(IWatcherManager::DEL_WATCHER, data, reply, option);
         EXPECT_EQ(reply.ReadInt32(), 0);
-        watcherManager->StopLoop();
+        watcherManager->OnStop();
         printf("TestDelWatcher %s watcherId %d %p \n", keyPrefix.c_str(), watcherId, watcherManager);
         return 0;
     }
 
+    int TestProcessWatcherMessage(const std::string &name, uint32_t watcherId)
+    {
+        WatcherManagerPtr watcherManager = GetWatcherManager();
+        WATCHER_CHECK(watcherManager != nullptr, return -1, "Failed to create manager");
+        const std::string value("test.value");
+        uint32_t msgSize = sizeof(ParamMessage) + sizeof(ParamMsgContent) + value.size();
+        msgSize = PARAM_ALIGN(msgSize); // align
+        std::vector<char> buffer(msgSize, 0);
+        ParamMessage *msg = (ParamMessage *)buffer.data();
+        WATCHER_CHECK(msg != NULL, return -1, "Invalid msg");
+        msg->type = MSG_NOTIFY_PARAM;
+        msg->msgSize = msgSize;
+        msg->id.watcherId = watcherId;
+        int ret = memcpy_s(msg->key, sizeof(msg->key), name.c_str(), name.size());
+        WATCHER_CHECK(ret == 0, return -1, "Failed to fill value");
+        uint32_t offset = 0;
+        ret = FillParamMsgContent(msg, &offset, PARAM_VALUE, value.c_str(), value.size());
+        WATCHER_CHECK(ret == 0, return -1, "Failed to fill value");
+        watcherManager->ProcessWatcherMessage(buffer, msgSize);
+        return 0;
+    }
+
+    int TestWatchProxy(const std::string &name, const std::string &value)
+    {
+        sptr<ISystemAbilityManager> systemMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        EXPECT_NE(systemMgr, nullptr);
+        sptr<IRemoteObject> remoteObj = systemMgr->GetSystemAbility(PARAM_WATCHER_DISTRIBUTED_SERVICE_ID);
+        EXPECT_NE(remoteObj, nullptr);
+        WatcherProxy *watcher = new WatcherProxy(remoteObj);
+        if (watcher != nullptr) {
+            watcher->OnParamerterChange(name, value);
+            delete watcher;
+        }
+        return 0;
+    }
+
     WatcherManagerPtr GetWatcherManager()
     {
         if (g_watcherManager == nullptr) {
@@ -97,6 +144,7 @@ public:
             if (g_watcherManager == nullptr) {
                 return nullptr;
             }
+            g_watcherManager->OnStart();
         }
         return g_watcherManager;
     }
@@ -107,6 +155,7 @@ HWTEST_F(WatcherProxyTest, TestAddWatcher, TestSize.Level1)
     WatcherProxyTest test;
     uint32_t watcherId = 0;
     test.TestAddWatcher("test.permission.watcher.test1", watcherId);
+    test.TestProcessWatcherMessage("test.permission.watcher.test1", watcherId);
 }
 
 HWTEST_F(WatcherProxyTest, TestAddWatcher2, TestSize.Level1)
@@ -129,9 +178,9 @@ HWTEST_F(WatcherProxyTest, TestAddWatcher4, TestSize.Level1)
 {
     WatcherProxyTest test;
     uint32_t watcherId = 0;
-    SystemSetParameter("test.permission.watcher.test4", "1101");
-    SystemSetParameter("test.permission.watcher.test4.test", "1102");
-    test.TestAddWatcher("test.permission.watcher.test*", watcherId);
+    SystemSetParameter("test.watcher.test4", "1101");
+    SystemSetParameter("test.watcher.test4.test", "1102");
+    test.TestAddWatcher("test.watcher.test4*", watcherId);
 }
 
 HWTEST_F(WatcherProxyTest, TestAddWatcher5, TestSize.Level1)
@@ -148,4 +197,10 @@ HWTEST_F(WatcherProxyTest, TestDelWatcher, TestSize.Level1)
     uint32_t watcherId = 0;
     test.TestAddWatcher("test.permission.watcher.testDel", watcherId);
     test.TestDelWatcher("test.permission.watcher.testDel", watcherId);
+}
+
+HWTEST_F(WatcherProxyTest, TestWatchProxy, TestSize.Level1)
+{
+    WatcherProxyTest test;
+    test.TestWatchProxy("test.permission.watcher.test1", "watcherId");
 }
\ No newline at end of file

services/test/unittest/tools/prepare_testdata.sh

@@ -85,7 +85,7 @@ hdc_shell_cmd "cp /data/init_ut/init_ut /bin/init_ut"
 hdc_shell_cmd "chmod 777 /data/init_ut/* -R"
 hdc_shell_cmd "chmod 777 /bin/init_ut"
 
-hdc_shell_cmd "export GCOV_PREFIX=${ut_target_path}/coverage&&export GCOV_PREFIX_STRIP=14&&init_ut"
+hdc_shell_cmd "export GCOV_PREFIX=${ut_target_path}/coverage&&export GCOV_PREFIX_STRIP=20&&init_ut"
 
 if [ $? -ne 0 ]; then
     echo "Execute init_ut in device failed. please check the log"

ueventd/ueventd_read_cfg.c

@@ -103,8 +103,8 @@ static int ParseDeviceConfig(char *p)
         INIT_LOGE("Invalid mode in config file for device node %s. use default mode", config->name);
         config->mode = DEVMODE;
     }
-    config->uid = (uid_t)StringToInt(items[DEVICE_CONFIG_UID_NUM], 0);
-    config->gid = (gid_t)StringToInt(items[DEVICE_CONFIG_GID_NUM], 0);
+    config->uid = (uid_t)DecodeUid(items[DEVICE_CONFIG_UID_NUM]);
+    config->gid = (gid_t)DecodeUid(items[DEVICE_CONFIG_GID_NUM]);
     ListAddTail(&g_devices, &config->list);
     FreeStringVector(items, count);
     return 0;
@@ -141,8 +141,8 @@ static int ParseSysfsConfig(char *p)
         INIT_LOGE("Invalid mode in config file for sys path %s. use default mode", config->sysPath);
         config->mode = DEVMODE;
     }
-    config->uid = (uid_t)StringToInt(items[SYS_CONFIG_UID_NUM], 0);
-    config->gid = (gid_t)StringToInt(items[SYS_CONFIG_GID_NUM], 0);
+    config->uid = (uid_t)DecodeUid(items[SYS_CONFIG_UID_NUM]);
+    config->gid = (gid_t)DecodeUid(items[SYS_CONFIG_GID_NUM]);
     ListAddTail(&g_sysDevices, &config->list);
     FreeStringVector(items, count);
     return 0;