diff --git a/services/cloudfiledaemon/include/cloud_disk/io_message_listener.h b/services/cloudfiledaemon/include/cloud_disk/io_message_listener.h
index e7e2f72850ec89a7e184e1218b15ff03a78b9d74..33268b2bb717471202d9651aaed1856f2bc02406 100644
--- a/services/cloudfiledaemon/include/cloud_disk/io_message_listener.h
+++ b/services/cloudfiledaemon/include/cloud_disk/io_message_listener.h
@@ -24,6 +24,7 @@
 
 #include "application_state_observer_stub.h"
 #include "common_event_subscriber.h"
+#include "ffrt_inner.h"
 
 namespace OHOS {
 namespace FileManagement {
@@ -47,24 +48,75 @@ struct IoDataToWrite {
     double result = 0;
 };
 
+using Int32Vector = std::vector<int32_t>;
+using Int64Vector = std::vector<int64_t>;
+using StringVector = std::vector<std::string>;
+using DoubleVector = std::vector<double>;
+bool CheckInt(const std::string &value);
+bool CheckDouble(const std::string &value);
+
+enum class VectorIndex {
+    IO_TIMES,
+    IO_BUNDLE_NAME,
+    IO_READ_CHAR_DIFF,
+    IO_SYSC_READ_DIFF,
+    IO_READ_BYTES_DIFF,
+    IO_SYSC_OPEN_DIFF,
+    IO_SYSC_STAT_DIFF,
+    IO_RESULT
+};
+using VectorVariant = std::variant<
+    Int32Vector,
+    StringVector,
+    Int64Vector,
+    DoubleVector
+>;
 class IoMessageManager {
 private:
     std::string currentBundleName = "";
     std::atomic<bool> isThreadRunning{false};
-    std::thread ioThread;
-    std::mutex sleepMutex;
-    std::condition_variable sleepCv;
+    std::atomic<bool> reportThreadRunning{false};
+    ffrt::mutex sleepMutex;
+    ffrt::condition_variable sleepCv;
     std::map<std::string, int32_t> bundleTimeMap;
     IoData currentData;
     IoData preData;
     IoDataToWrite dataToWrite;
     AppExecFwk::AppStateData lastestAppStateData;
 
+    Int32Vector ioTimes;
+    StringVector ioBundleName;
+    Int64Vector ioReadCharDiff;
+    Int64Vector ioSyscReadDiff;
+    Int64Vector ioReadBytesDiff;
+    Int64Vector ioSyscOpenDiff;
+    Int64Vector ioSyscStatDiff;
+    DoubleVector ioResult;
+
+    std::vector<VectorVariant> targetVectors = {
+        VectorVariant(std::in_place_type<Int32Vector>, std::move(ioTimes)),
+        VectorVariant(std::in_place_type<StringVector>, std::move(ioBundleName)),
+        VectorVariant(std::in_place_type<Int64Vector>, std::move(ioReadCharDiff)),
+        VectorVariant(std::in_place_type<Int64Vector>, std::move(ioSyscReadDiff)),
+        VectorVariant(std::in_place_type<Int64Vector>, std::move(ioReadBytesDiff)),
+        VectorVariant(std::in_place_type<Int64Vector>, std::move(ioSyscOpenDiff)),
+        VectorVariant(std::in_place_type<Int64Vector>, std::move(ioSyscStatDiff)),
+        VectorVariant(std::in_place_type<DoubleVector>, std::move(ioResult))
+    };
+
+    template <typename T, VectorIndex Index>
+    T& GetVector(std::vector<VectorVariant>& targetVectors)
+    {
+        return std::get<T>(targetVectors[static_cast<size_t>(Index)]);
+    }
     bool ReadIoDataFromFile(const std::string &path);
     void RecordDataToFile(const std::string &path);
-    bool IsFirstLineHeader(const std::string &path);
     void RecordIoData();
     void ProcessIoData(const std::string &path);
+    void PushData(const std::vector<std::string> &fields);
+    void ReadAndReportIoMessage();
+    void CheckMaxSizeAndReport();
+    void Report();
 
 public:
     static IoMessageManager &GetInstance();
diff --git a/services/cloudfiledaemon/src/cloud_disk/io_message_listener.cpp b/services/cloudfiledaemon/src/cloud_disk/io_message_listener.cpp
index 6848656f7f104002eb3fc982ebe0ccbdb5bbcd17..3a1f3ed485ca1a0fa9eb56e5295fe35973e1db30 100644
--- a/services/cloudfiledaemon/src/cloud_disk/io_message_listener.cpp
+++ b/services/cloudfiledaemon/src/cloud_disk/io_message_listener.cpp
@@ -14,6 +14,8 @@
  */
 #include "io_message_listener.h"
 
+#include <chrono>
+#include "hisysevent.h"
 #include "utils_log.h"
 
 using namespace std;
@@ -28,9 +30,14 @@ const int32_t GET_FREQUENCY = 5;
 const int32_t READ_THRESHOLD = 1000;
 const int32_t OPEN_THRESHOLD = 1000;
 const int32_t STAT_THRESHOLD = 1000;
-const string IO_DATA_FILE_PATH = "/data/service/el1/public/cloudfile/rdb/io_message.csv";
+const string IO_DATA_FILE_PATH = "/data/service/el1/public/cloudfile/io/";
+const string IO_FILE_NAME = "io_message.csv";
+const string IO_NEED_REPORT_PREFIX = "wait_report_";
 const int32_t TYPE_FRONT = 2;
 const int32_t TYPE_BACKGROUND = 4;
+const int32_t MAX_IO_FILE_SIZE = 128 * 1024;
+const size_t MAX_RECORD_IN_FILE = 10000;
+const size_t MAX_IO_REPORT_NUMBER = 100;
 
 IoMessageManager &IoMessageManager::GetInstance()
 {
@@ -75,17 +82,6 @@ bool IoMessageManager::ReadIoDataFromFile(const std::string &path)
     return true;
 }
 
-bool IoMessageManager::IsFirstLineHeader(const string &path)
-{
-    ifstream inFile(path);
-    if (!inFile.is_open()) {
-        return false;
-    }
-
-    string firstLine;
-    getline(inFile, firstLine);
-    return firstLine.find("time") != string::npos;
-}
 
 void IoMessageManager::RecordDataToFile(const string &path)
 {
@@ -95,10 +91,6 @@ void IoMessageManager::RecordDataToFile(const string &path)
         return;
     }
 
-    if (!IsFirstLineHeader(path)) {
-        outFile << "time, bundle_name, rchar_diff, syscr_diff, read_bytes_diff, syscopen_diff, syscstat_diff, result\n";
-    }
-
     outFile << bundleTimeMap[dataToWrite.bundleName] << ","
             << dataToWrite.bundleName << ","
             << dataToWrite.rcharDiff << ","
@@ -110,6 +102,231 @@ void IoMessageManager::RecordDataToFile(const string &path)
     LOGI("Write io data success");
 }
 
+static vector<const char*> ConvertToCStringArray(const vector<string>& vec)
+{
+    vector<const char*> cstrVec;
+    for (const auto& str : vec) {
+        cstrVec.push_back(str.c_str());
+    }
+    return cstrVec;
+}
+
+template <typename T>
+void PushField(const std::string &value, std::vector<T> &vec)
+{
+    if constexpr (std::is_same_v<T, int32_t>) {
+        vec.push_back(std::stoi(value));
+    } else if constexpr (std::is_same_v<T, int64_t>) {
+        vec.push_back(std::stoll(value));
+    } else if constexpr (std::is_same_v<T, double>) {
+        vec.push_back(std::stod(value));
+    } else {
+        vec.push_back(value);
+    }
+}
+
+bool CheckInt(const std::string &value)
+{
+    if (value.empty()) {
+        return false;
+    }
+    if (!all_of(value.begin(), value.end(), ::isdigit)) {
+        return false;
+    }
+    return true;
+}
+
+bool CheckDouble(const std::string &value)
+{
+    if (value.empty()) {
+        return false;
+    }
+
+    errno = 0;
+    char *endptr;
+    std::strtod(value.c_str(), &endptr);
+    if (errno != 0) {
+        return false;
+    }
+    return *endptr == '\0';
+}
+
+struct PushBackVisitor {
+    const std::string &value;
+
+    template<typename T>
+    void operator()(std::vector<T> &vec)
+    {
+        PushField(value, vec);
+    }
+};
+
+struct CheckVisitor {
+    const std::string &value;
+    bool &checkType;
+
+    template<typename T>
+    void operator()(std::vector<T> &vec)
+    {
+        if constexpr (std::is_same_v<T, int32_t>) {
+            checkType = CheckInt(value);
+        } else if constexpr (std::is_same_v<T, int64_t>) {
+            checkType = CheckInt(value);
+        } else if constexpr (std::is_same_v<T, double>) {
+            checkType = CheckDouble(value);
+        } else if constexpr (std::is_same_v<T, std::string>) {
+            checkType = true;
+        }
+    }
+};
+
+template <typename T>
+HiSysEventParam CreateParam(const std::string name, HiSysEventParamType type, std::vector<T> &data)
+{
+    HiSysEventParam param;
+    std::copy(name.begin(), name.begin() + std::min(name.length(), sizeof(param.name) - 1), param.name);
+    param.name[sizeof(param.name) - 1] = '\0';
+    param.t = type;
+    param.v.array = data.data();
+    param.arraySize = static_cast<int>(data.size());
+    return param;
+}
+
+void IoMessageManager::Report()
+{
+    auto sizeVector = [](auto &vec) {
+        if (vec.size() == 0) {
+            return;
+        }
+    };
+    for (auto &variant : targetVectors) {
+        std::visit(sizeVector, variant);
+    }
+    auto charIoBundleName = ConvertToCStringArray(GetVector<StringVector, VectorIndex::IO_BUNDLE_NAME>(targetVectors));
+    HiSysEventParam params[] = {
+        CreateParam("time", HISYSEVENT_INT32_ARRAY, GetVector<Int32Vector, VectorIndex::IO_TIMES>(targetVectors)),
+        CreateParam("BundleName", HISYSEVENT_STRING_ARRAY, charIoBundleName),
+        CreateParam("ReadCharDiff", HISYSEVENT_INT64_ARRAY,
+            GetVector<Int64Vector, VectorIndex::IO_READ_CHAR_DIFF>(targetVectors)),
+        CreateParam("SyscReadDiff", HISYSEVENT_INT64_ARRAY,
+            GetVector<Int64Vector, VectorIndex::IO_SYSC_READ_DIFF>(targetVectors)),
+        CreateParam("ReadBytesDiff", HISYSEVENT_INT64_ARRAY,
+            GetVector<Int64Vector, VectorIndex::IO_READ_BYTES_DIFF>(targetVectors)),
+        CreateParam("SyscOpenDiff", HISYSEVENT_INT64_ARRAY,
+            GetVector<Int64Vector, VectorIndex::IO_SYSC_OPEN_DIFF>(targetVectors)),
+        CreateParam("SyscStatDiff", HISYSEVENT_INT64_ARRAY,
+            GetVector<Int64Vector, VectorIndex::IO_SYSC_STAT_DIFF>(targetVectors)),
+        CreateParam("Result", HISYSEVENT_DOUBLE_ARRAY,
+            GetVector<DoubleVector, VectorIndex::IO_RESULT>(targetVectors)),
+    };
+
+    auto ret = OH_HiSysEvent_Write(
+        "HM_FS",
+        "ABNORMAL_IO_STATISTICS_DATA",
+        HISYSEVENT_STATISTIC,
+        params,
+        sizeof(params) / sizeof(params[0])
+    );
+    if (ret != 0) {
+        LOGE("Report failed, err : %{public}d", ret);
+    }
+    auto clearVector = [](auto &vec) {
+        vec.clear();
+    };
+    for (auto &variant : targetVectors) {
+        std::visit(clearVector, variant);
+    }
+}
+
+void IoMessageManager::PushData(const vector<string> &fields)
+{
+    if (fields.size() != targetVectors.size()) {
+        return;
+    }
+    for (uint32_t i = 0; i < fields.size(); ++i) {
+        bool checkType = false;
+        CheckVisitor visitor{fields[i], checkType};
+        std::visit(visitor, targetVectors[i]);
+        if (!checkType) {
+            LOGI("checkType failed. value = %{public}s", fields[i].c_str());
+            return;
+        }
+    }
+    for (uint32_t i = 0; i < fields.size(); ++i) {
+        PushBackVisitor visitor{fields[i]};
+        std::visit(visitor, targetVectors[i]);
+    }
+    return;
+}
+
+void IoMessageManager::ReadAndReportIoMessage()
+{
+    ifstream localData(IO_DATA_FILE_PATH + IO_NEED_REPORT_PREFIX + IO_FILE_NAME);
+    if (!localData) {
+        LOGE("Open cloud data statistic local data fail : %{public}d", errno);
+        return;
+    }
+
+    string line;
+    size_t reportCount = 0;
+    size_t totalCount = 0;
+    while (getline(localData, line)) {
+        vector<string> fields;
+        istringstream iss(line);
+        string token;
+
+        while (getline(iss, token, ',')) {
+            fields.push_back(token);
+        }
+
+        PushData(fields);
+        reportCount++;
+        totalCount++;
+        if (reportCount >= MAX_IO_REPORT_NUMBER) {
+            Report();
+            reportCount = 0;
+        }
+        if (totalCount >= MAX_RECORD_IN_FILE) {
+            break;
+        }
+    }
+    if (reportCount > 0) {
+        Report();
+    }
+    bool ret = filesystem::remove(IO_DATA_FILE_PATH + IO_NEED_REPORT_PREFIX + IO_FILE_NAME);
+    if (!ret) {
+        LOGE("Failed to remove need_report_io_file, err:%{public}d", errno);
+    }
+    reportThreadRunning.store(false);
+}
+
+void IoMessageManager::CheckMaxSizeAndReport()
+{
+    std::error_code errCode;
+    if (!filesystem::exists(IO_DATA_FILE_PATH + IO_FILE_NAME, errCode) || errCode.value() != 0) {
+        LOGE("source file not exist");
+        return;
+    }
+    auto fileSize = filesystem::file_size(IO_DATA_FILE_PATH + IO_FILE_NAME, errCode);
+    if (fileSize < MAX_IO_FILE_SIZE || errCode.value() != 0) {
+        return;
+    }
+    if (filesystem::exists(IO_DATA_FILE_PATH + IO_NEED_REPORT_PREFIX + IO_FILE_NAME)) {
+        LOGI("Report file exist");
+    }
+    filesystem::rename(IO_DATA_FILE_PATH + IO_FILE_NAME,
+        IO_DATA_FILE_PATH + IO_NEED_REPORT_PREFIX + IO_FILE_NAME, errCode);
+    if (errCode.value() != 0) {
+        LOGE("Failed to rename file, error code: %{public}d", errCode.value());
+        return;
+    }
+    if (!reportThreadRunning.load()) {
+        reportThreadRunning.store(true);
+        LOGI("Start report io data");
+        ffrt::submit([this] { ReadAndReportIoMessage(); }, {}, {}, ffrt::task_attr().qos(ffrt::qos_background));
+    }
+}
+
 void IoMessageManager::ProcessIoData(const string &path)
 {
     if (currentBundleName != lastestAppStateData.bundleName) {
@@ -141,7 +358,8 @@ void IoMessageManager::ProcessIoData(const string &path)
     if (dataToWrite.result >= READ_THRESHOLD ||
         dataToWrite.syscopenDiff >= OPEN_THRESHOLD ||
         dataToWrite.syscstatDiff >= STAT_THRESHOLD) {
-        RecordDataToFile(IO_DATA_FILE_PATH);
+        CheckMaxSizeAndReport();
+        RecordDataToFile(IO_DATA_FILE_PATH + IO_FILE_NAME);
     }
 
     preData = currentData;
@@ -155,7 +373,7 @@ void IoMessageManager::RecordIoData()
             string path = "/proc/" + to_string(lastestAppStateData.pid) + "/sys_count";
             ProcessIoData(path);
         }
-        unique_lock<mutex> lock(sleepMutex);
+        unique_lock<ffrt::mutex> lock(sleepMutex);
         sleepCv.wait_for(lock, chrono::seconds(GET_FREQUENCY), [&] {
             return !isThreadRunning.load();
         });
@@ -164,28 +382,23 @@ void IoMessageManager::RecordIoData()
 
 void IoMessageManager::OnReceiveEvent(const AppExecFwk::AppStateData &appStateData)
 {
-    if (appStateData.bundleName != DESK_BUNDLE_NAME) {
-        if (appStateData.state == TYPE_FRONT) {
-            lastestAppStateData = appStateData;
-            if (!ioThread.joinable()) {
-                isThreadRunning.store(true);
-                ioThread = thread(&IoMessageManager::RecordIoData, this);
-            }
-            return;
-        }
-        if (appStateData.state == TYPE_BACKGROUND) {
-            if (ioThread.joinable()) {
-                {
-                    lock_guard<mutex> lock(sleepMutex);
-                    isThreadRunning.store(false);
-                }
-                sleepCv.notify_all();
-                ioThread.join();
-                ioThread = thread();
-                currentData = {};
-                preData = {};
-            }
+    if (appStateData.bundleName == DESK_BUNDLE_NAME) {
+        return;
+    }
+    if (appStateData.state == TYPE_FRONT) {
+        lastestAppStateData = appStateData;
+        if (!isThreadRunning.load()) {
+            isThreadRunning.store(true);
+            ffrt::submit([this] {RecordIoData();}, {}, {}, ffrt::task_attr().qos(ffrt::qos_background));
         }
+        return;
+    }
+    if (appStateData.state == TYPE_BACKGROUND) {
+        lock_guard<ffrt::mutex> lock(sleepMutex);
+        isThreadRunning.store(false);
+        sleepCv.notify_all();
+        currentData = {};
+        preData = {};
     }
 }
 } // namespace CloudDisk
diff --git a/services/cloudfiledaemon/src/ipc/cloud_daemon.cpp b/services/cloudfiledaemon/src/ipc/cloud_daemon.cpp
index 98d14d79c9ca2f497bed8b22f37edec9e8b7bdcf..cf0e3729f65fae117556d9cb5b39a22416ad777a 100644
--- a/services/cloudfiledaemon/src/ipc/cloud_daemon.cpp
+++ b/services/cloudfiledaemon/src/ipc/cloud_daemon.cpp
@@ -45,6 +45,7 @@ using namespace std;
 using namespace CloudDisk;
 
 namespace {
+    static const string IO_MESSAGE_DIR = "/data/service/el1/public/cloudfile/io/";
     static const string BETA_VERSION = "beta";
     static const string CN_REGION = "CN";
     static const string GLOBAL_REGION = "const.global.region";
@@ -133,6 +134,16 @@ void CloudDaemon::OnStart()
     if (ShouldRegisterListener()) {
         auto bundleNameList = vector<string>{};
         std::thread listenThread([bundleNameList] {
+            if (filesystem::exists(IO_MESSAGE_DIR)) {
+                CloudDisk::AppStateObserverManager::GetInstance().SubscribeAppState(bundleNameList);
+                return;
+            }
+            std::error_code errCode;
+            filesystem::create_directories(IO_MESSAGE_DIR, errCode);
+            if (errCode.value() != 0) {
+                LOGE("Mkdir for io failed");
+                return;
+            }
             CloudDisk::AppStateObserverManager::GetInstance().SubscribeAppState(bundleNameList);
         });
         listenThread.detach();
diff --git a/test/unittests/cloud_disk/io_message_listener_test.cpp b/test/unittests/cloud_disk/io_message_listener_test.cpp
index 89faf55bb45687eb4413d3406c7b6a06067c4dea..a6c14b6e948cd5fd10a867a2e027388235fa4c7a 100644
--- a/test/unittests/cloud_disk/io_message_listener_test.cpp
+++ b/test/unittests/cloud_disk/io_message_listener_test.cpp
@@ -17,6 +17,7 @@
 
 #include <cstring>
 #include <fcntl.h>
+#include <fstream>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <unistd.h>
@@ -38,6 +39,14 @@ const int32_t THREAD_SLEEP_TIME = 100;
 const int32_t FRONT_EVENT = 2;
 const int32_t BACKGROUND_EVENT = 4;
 const int32_t UNKNOWN_EVENT = 8;
+const string TEST_INT32 = "100000";
+const string TEST_INT64 = "200000";
+const string TEST_DOUBLE = "888.123";
+const int32_t LOOP_COUNT = 20000;
+const int32_t FEWER_LOOP_COUNT = 101;
+const string IO_REPORT_FILE = "/data/service/el1/public/cloudfile/io/wait_report_io_message.csv";
+const string IO_FILE = "/data/service/el1/public/cloudfile/io/io_message.csv";
+
 
 class IoMessageListenerTest : public testing::Test {
 public:
@@ -553,74 +562,6 @@ HWTEST_F(IoMessageListenerTest, ReadIoDataFromFileTest017, TestSize.Level1)
     GTEST_LOG_(INFO) << "ReadIoDataFromFileTest017 End";
 }
 
-/**
- * @tc.name: IsFirstLineHeaderTest001
- * @tc.desc: Read IO data
- * @tc.type: FUNC
- * @tc.require: issuesI92WQP
- */
-HWTEST_F(IoMessageListenerTest, IsFirstLineHeaderTest001, TestSize.Level1)
-{
-    GTEST_LOG_(INFO) << "IsFirstLineHeaderTest001 Start";
-    string path = "/data/service/el1/public/cloudfile/rdb/1.txt";
-    try {
-        bool ret = ioMessageManager_->IsFirstLineHeader(path);
-        EXPECT_FALSE(ret);
-    } catch (...) {
-        EXPECT_FALSE(true);
-        GTEST_LOG_(INFO) << "IsFirstLineHeaderTest001 ERROR";
-    }
-    GTEST_LOG_(INFO) << "IsFirstLineHeaderTest001 End";
-}
-
-/**
- * @tc.name: IsFirstLineHeaderTest002
- * @tc.desc: Read IO data
- * @tc.type: FUNC
- * @tc.require: issuesI92WQP
- */
-HWTEST_F(IoMessageListenerTest, IsFirstLineHeaderTest002, TestSize.Level1)
-{
-    GTEST_LOG_(INFO) << "IsFirstLineHeaderTest002 Start";
-    string path = "/data/service/el1/public/cloudfile/rdb/1.txt";
-    try {
-        int fd = open(path.c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0644);
-        close(fd);
-        bool ret = ioMessageManager_->IsFirstLineHeader(path);
-        EXPECT_FALSE(ret);
-    } catch (...) {
-        EXPECT_FALSE(true);
-        GTEST_LOG_(INFO) << "IsFirstLineHeaderTest002 ERROR";
-    }
-    unlink(path.c_str());
-    GTEST_LOG_(INFO) << "IsFirstLineHeaderTest002 End";
-}
-
-/**
- * @tc.name: IsFirstLineHeaderTest003
- * @tc.desc: Read IO data
- * @tc.type: FUNC
- * @tc.require: issuesI92WQP
- */
-HWTEST_F(IoMessageListenerTest, IsFirstLineHeaderTest003, TestSize.Level1)
-{
-    GTEST_LOG_(INFO) << "IsFirstLineHeaderTest003 Start";
-    string path = "/data/service/el1/public/cloudfile/rdb/1.txt";
-    try {
-        int fd = open(path.c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0644);
-        string line1 = "time\n";
-        write(fd, line1.c_str(), line1.size());
-        close(fd);
-        bool ret = ioMessageManager_->IsFirstLineHeader(path);
-        EXPECT_TRUE(ret);
-    } catch (...) {
-        EXPECT_TRUE(false);
-        GTEST_LOG_(INFO) << "IsFirstLineHeaderTest003 ERROR";
-    }
-    unlink(path.c_str());
-    GTEST_LOG_(INFO) << "IsFirstLineHeaderTest003 End";
-}
-
 /**
  * @tc.name: RecordDataToFileTest001
  * @tc.desc: Read IO data
@@ -691,6 +632,26 @@ HWTEST_F(IoMessageListenerTest, RecordDataToFileTest003, TestSize.Level1)
     GTEST_LOG_(INFO) << "RecordDataToFileTest003 End";
 }
 
+/**
+ * @tc.name: RecordDataToFileTest004
+ * @tc.desc: Read IO data
+ * @tc.type: FUNC
+ * @tc.require: issuesI92WQP
+ */
+HWTEST_F(IoMessageListenerTest, RecordDataToFileTest004, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "RecordDataToFileTest004 Start";
+    string path = "";
+    try {
+        ioMessageManager_->RecordDataToFile(path);
+        EXPECT_FALSE(false);
+    } catch (...) {
+        EXPECT_FALSE(true);
+        GTEST_LOG_(INFO) << "RecordDataToFileTest004 ERROR";
+    }
+    GTEST_LOG_(INFO) << "RecordDataToFileTest004 End";
+}
+
 /**
  * @tc.name: ProcessIoDataTest001
  * @tc.desc: Read IO data
@@ -1284,7 +1245,6 @@ HWTEST_F(IoMessageListenerTest, OnReceiveEventTest002, TestSize.Level1)
         AppExecFwk::AppStateData appStateData;
         appStateData.bundleName = "";
         appStateData.state = FRONT_EVENT;
-        ioMessageManager_->ioThread =std::thread();
         ioMessageManager_->OnReceiveEvent(appStateData);
         EXPECT_TRUE(true);
     } catch (...) {
@@ -1338,4 +1298,583 @@ HWTEST_F(IoMessageListenerTest, OnReceiveEventTest005, TestSize.Level1)
     GTEST_LOG_(INFO) << "OnReceiveEventTest005 End";
 }
 
+/**
+ * @tc.name: Report001
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, Report001, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "Report001 Start";
+    for (int i = 0; i <= FEWER_LOOP_COUNT; i++) {
+        ioMessageManager_->ioTimes.push_back(1);
+        ioMessageManager_->ioBundleName.push_back("tdd");
+        ioMessageManager_->ioReadCharDiff.push_back(1);
+        ioMessageManager_->ioSyscReadDiff.push_back(1);
+        ioMessageManager_->ioReadBytesDiff.push_back(1);
+        ioMessageManager_->ioSyscOpenDiff.push_back(1);
+        ioMessageManager_->ioSyscStatDiff.push_back(1);
+        ioMessageManager_->ioResult.push_back(1.0);
+    }
+    try {
+        ioMessageManager_->Report();
+        EXPECT_FALSE(false);
+    } catch (...) {
+        EXPECT_FALSE(true);
+        GTEST_LOG_(INFO) << "Report001 ERROR";
+    }
+    GTEST_LOG_(INFO) << "Report001 End";
+}
+
+/**
+ * @tc.name: Report002
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, Report002, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "Report002 Start";
+    for (int i = 0; i <= 10; i++) {
+        ioMessageManager_->ioTimes.push_back(1);
+        ioMessageManager_->ioBundleName.push_back("tdd");
+        ioMessageManager_->ioReadCharDiff.push_back(1);
+        ioMessageManager_->ioSyscReadDiff.push_back(1);
+        ioMessageManager_->ioReadBytesDiff.push_back(1);
+        ioMessageManager_->ioSyscOpenDiff.push_back(1);
+        ioMessageManager_->ioSyscStatDiff.push_back(1);
+        ioMessageManager_->ioResult.push_back(1.0);
+    }
+    try {
+        ioMessageManager_->Report();
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "Report002 ERROR";
+    }
+    GTEST_LOG_(INFO) << "Report002 End";
+}
+
+/**
+ * @tc.name: Report003
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, Report003, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "Report003 Start";
+    try {
+        ioMessageManager_->Report();
+        EXPECT_FALSE(false);
+    } catch (...) {
+        EXPECT_FALSE(true);
+        GTEST_LOG_(INFO) << "Report003 ERROR";
+    }
+    GTEST_LOG_(INFO) << "Report003 End";
+}
+
+/**
+ * @tc.name: PushData001
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, PushData001, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "PushData001 Start";
+    vector<string> fields;
+    try {
+        ioMessageManager_->PushData(fields);
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "PushData001 ERROR";
+    }
+    GTEST_LOG_(INFO) << "PushData001 End";
+}
+
+/**
+ * @tc.name: PushData002
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, PushData002, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "PushData002 Start";
+    vector<string> fields;
+    fields.push_back("tdd,tdd,tdd,tdd,tdd,tdd,tdd,tdd");
+    try {
+        ioMessageManager_->PushData(fields);
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "PushData002 ERROR";
+    }
+    GTEST_LOG_(INFO) << "PushData002 End";
+}
+
+/**
+ * @tc.name: PushData003
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, PushData003, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "PushData003 Start";
+    vector<string> fields;
+    fields.push_back("tdd");
+    fields.push_back("tdd");
+    fields.push_back("tdd");
+    fields.push_back("tdd");
+    fields.push_back("tdd");
+    fields.push_back("tdd");
+    fields.push_back("tdd");
+    fields.push_back("tdd");
+    try {
+        ioMessageManager_->PushData(fields);
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "PushData003 ERROR";
+    }
+    GTEST_LOG_(INFO) << "PushData003 End";
+}
+
+/**
+ * @tc.name: PushData004
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, PushData004, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "PushData004 Start";
+    vector<string> fields;
+    fields.push_back(TEST_INT32);
+    fields.push_back("tdd");
+    fields.push_back(TEST_INT64);
+    fields.push_back(TEST_INT64);
+    fields.push_back(TEST_INT64);
+    fields.push_back(TEST_INT64);
+    fields.push_back(TEST_INT64);
+    fields.push_back(TEST_DOUBLE);
+    try {
+        ioMessageManager_->PushData(fields);
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "PushData004 ERROR";
+    }
+    GTEST_LOG_(INFO) << "PushData004 End";
+}
+
+/**
+ * @tc.name: ReadAndReportIoMessage001
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, ReadAndReportIoMessage001, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ReadAndReportIoMessage001 Start";
+    
+    try {
+        if (filesystem::exists(IO_REPORT_FILE)) {
+            filesystem::remove(IO_REPORT_FILE);
+        }
+        ioMessageManager_->Report();
+        EXPECT_FALSE(false);
+    } catch (...) {
+        EXPECT_FALSE(true);
+        GTEST_LOG_(INFO) << "ReadAndReportIoMessage001 ERROR";
+    }
+    GTEST_LOG_(INFO) << "ReadAndReportIoMessage001 End";
+}
+
+/**
+ * @tc.name: ReadAndReportIoMessage002
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, ReadAndReportIoMessage002, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ReadAndReportIoMessage002 Start";
+    
+    try {
+        int fd = -1;
+        if (!filesystem::exists(IO_REPORT_FILE)) {
+            fd = open(IO_REPORT_FILE.c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0644);
+            close(fd);
+        }
+
+        ioMessageManager_->ReadAndReportIoMessage();
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ReadAndReportIoMessage002 ERROR";
+    }
+    unlink(IO_REPORT_FILE.c_str());
+    GTEST_LOG_(INFO) << "ReadAndReportIoMessage002 End";
+}
+
+/**
+ * @tc.name: ReadAndReportIoMessage003
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, ReadAndReportIoMessage003, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ReadAndReportIoMessage003 Start";
+    
+    try {
+        int fd = -1;
+        if (!filesystem::exists(IO_REPORT_FILE)) {
+            fd = open(IO_REPORT_FILE.c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0644);
+        }
+        string line1 = "tdd tdd tdd tdd tdd tdd tdd tdd\n";
+        write(fd, line1.c_str(), line1.size());
+        close(fd);
+
+        ioMessageManager_->ReadAndReportIoMessage();
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ReadAndReportIoMessage003 ERROR";
+    }
+    unlink(IO_REPORT_FILE.c_str());
+    GTEST_LOG_(INFO) << "ReadAndReportIoMessage003 End";
+}
+
+/**
+ * @tc.name: ReadAndReportIoMessage004
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, ReadAndReportIoMessage004, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ReadAndReportIoMessage004 Start";
+    
+    try {
+        int fd = -1;
+        if (!filesystem::exists(IO_REPORT_FILE)) {
+            fd = open(IO_REPORT_FILE.c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0644);
+        }
+        string line1 = "tdd,tdd,tdd,tdd,tdd,tdd,tdd,tdd\n";
+        write(fd, line1.c_str(), line1.size());
+        close(fd);
+
+        ioMessageManager_->ReadAndReportIoMessage();
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ReadAndReportIoMessage004 ERROR";
+    }
+    unlink(IO_REPORT_FILE.c_str());
+    GTEST_LOG_(INFO) << "ReadAndReportIoMessage004 End";
+}
+
+/**
+ * @tc.name: ReadAndReportIoMessage005
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, ReadAndReportIoMessage005, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ReadAndReportIoMessage005 Start";
+    
+    try {
+        int fd = -1;
+        if (!filesystem::exists(IO_REPORT_FILE)) {
+            fd = open(IO_REPORT_FILE.c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0644);
+        }
+        for (int i = 0; i <= FEWER_LOOP_COUNT; i++) {
+            string line = "tdd,tdd,tdd,tdd,tdd,tdd,tdd,tdd\n";
+            write(fd, line.c_str(), line.size());
+        }
+        close(fd);
+
+        ioMessageManager_->ReadAndReportIoMessage();
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ReadAndReportIoMessage005 ERROR";
+    }
+    unlink(IO_REPORT_FILE.c_str());
+    GTEST_LOG_(INFO) << "ReadAndReportIoMessage005 End";
+}
+
+/**
+ * @tc.name: CheckMaxSizeAndReport001
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, CheckMaxSizeAndReport001, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "CheckMaxSizeAndReport001 Start";
+    
+    try {
+        int fd = -1;
+        if (filesystem::exists(IO_FILE)) {
+            unlink(IO_FILE.c_str());
+        }
+        fd = open(IO_FILE.c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0644);
+        string line = "test,test,test,test,test,test,test,test\n";
+        write(fd, line.c_str(), line.size());
+        close(fd);
+
+        ioMessageManager_->CheckMaxSizeAndReport();
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "CheckMaxSizeAndReport001 ERROR";
+    }
+    GTEST_LOG_(INFO) << "CheckMaxSizeAndReport001 End";
+}
+
+/**
+ * @tc.name: CheckMaxSizeAndReport002
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, CheckMaxSizeAndReport002, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "CheckMaxSizeAndReport002 Start";
+    
+    try {
+        int fd = -1;
+        if (filesystem::exists(IO_FILE)) {
+            unlink(IO_FILE.c_str());
+        }
+        fd = open(IO_FILE.c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0644);
+        string line = "tdd,tdd,tdd,tdd,tdd,tdd,tdd,tdd\n";
+        write(fd, line.c_str(), line.size());
+        close(fd);
+
+        ioMessageManager_->CheckMaxSizeAndReport();
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "CheckMaxSizeAndReport002 ERROR";
+    }
+    unlink(IO_FILE.c_str());
+    GTEST_LOG_(INFO) << "CheckMaxSizeAndReport002 End";
+}
+
+/**
+ * @tc.name: CheckMaxSizeAndReport003
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, CheckMaxSizeAndReport003, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "CheckMaxSizeAndReport003 Start";
+    
+    try {
+        int fd = -1;
+        if (filesystem::exists(IO_FILE)) {
+            unlink(IO_FILE.c_str());
+        }
+        fd = open(IO_FILE.c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0644);
+        for (int i = 0; i <= LOOP_COUNT; i++) {
+            string line = "tdd,tdd,tdd,tdd,tdd,tdd,tdd,tdd\n";
+            write(fd, line.c_str(), line.size());
+        }
+        close(fd);
+
+        if (!filesystem::exists(IO_REPORT_FILE)) {
+            int fd2 = open(IO_REPORT_FILE.c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0644);
+            close(fd2);
+        }
+        ioMessageManager_->CheckMaxSizeAndReport();
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "CheckMaxSizeAndReport003 ERROR";
+    }
+    unlink(IO_FILE.c_str());
+    unlink(IO_REPORT_FILE.c_str());
+    GTEST_LOG_(INFO) << "CheckMaxSizeAndReport003 End";
+}
+
+/**
+ * @tc.name: CheckMaxSizeAndReport004
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, CheckMaxSizeAndReport004, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "CheckMaxSizeAndReport004 Start";
+    
+    try {
+        int fd = -1;
+        if (filesystem::exists(IO_FILE)) {
+            unlink(IO_FILE.c_str());
+        }
+        fd = open(IO_FILE.c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0644);
+        for (int i = 0; i <= LOOP_COUNT; i++) {
+            string line = "tdd,tdd,tdd,tdd,tdd,tdd,tdd,tdd\n";
+            write(fd, line.c_str(), line.size());
+        }
+        close(fd);
+
+        if (filesystem::exists(IO_REPORT_FILE)) {
+            unlink(IO_REPORT_FILE.c_str());
+        }
+        ioMessageManager_->CheckMaxSizeAndReport();
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "CheckMaxSizeAndReport004 ERROR";
+    }
+    unlink(IO_FILE.c_str());
+    unlink(IO_REPORT_FILE.c_str());
+    GTEST_LOG_(INFO) << "CheckMaxSizeAndReport004 End";
+}
+
+/**
+ * @tc.name: CheckMaxSizeAndReport005
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, CheckMaxSizeAndReport005, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "CheckMaxSizeAndReport005 Start";
+    
+    try {
+        int fd = -1;
+        if (filesystem::exists(IO_FILE)) {
+            unlink(IO_FILE.c_str());
+        }
+        fd = open(IO_FILE.c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0644);
+        for (int i = 0; i <= LOOP_COUNT; i++) {
+            string line = "tdd,tdd,tdd,tdd,tdd,tdd,tdd,tdd\n";
+            write(fd, line.c_str(), line.size());
+        }
+        close(fd);
+
+        if (filesystem::exists(IO_REPORT_FILE)) {
+            unlink(IO_REPORT_FILE.c_str());
+        }
+        ioMessageManager_->reportThreadRunning.store(true);
+        ioMessageManager_->CheckMaxSizeAndReport();
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "CheckMaxSizeAndReport005 ERROR";
+    }
+    unlink(IO_FILE.c_str());
+    unlink(IO_REPORT_FILE.c_str());
+    GTEST_LOG_(INFO) << "CheckMaxSizeAndReport005 End";
+}
+
+/**
+ * @tc.name: CheckInt001
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, CheckInt001, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "CheckInt001 Start";
+    
+    try {
+        OHOS::FileManagement::CloudDisk::CheckInt("1234");
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "CheckInt001 ERROR";
+    }
+    GTEST_LOG_(INFO) << "CheckInt001 End";
+}
+
+/**
+ * @tc.name: CheckInt002
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, CheckInt002, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "CheckInt002 Start";
+    
+    try {
+        OHOS::FileManagement::CloudDisk::CheckInt("str");
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "CheckInt002 ERROR";
+    }
+    GTEST_LOG_(INFO) << "CheckInt002 End";
+}
+
+/**
+ * @tc.name: CheckInt003
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, CheckInt003, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "CheckInt003 Start";
+    
+    try {
+        OHOS::FileManagement::CloudDisk::CheckInt("");
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "CheckInt003 ERROR";
+    }
+    GTEST_LOG_(INFO) << "CheckInt003 End";
+}
+
+/**
+ * @tc.name: CheckDouble001
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, CheckDouble001, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "CheckDouble001 Start";
+    
+    try {
+        OHOS::FileManagement::CloudDisk::CheckDouble("1.0");
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "CheckDouble001 ERROR";
+    }
+    GTEST_LOG_(INFO) << "CheckInt001 End";
+}
+
+/**
+ * @tc.name: CheckDouble002
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, CheckDouble002, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "CheckDouble002 Start";
+    
+    try {
+        OHOS::FileManagement::CloudDisk::CheckDouble("str");
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "CheckDouble002 ERROR";
+    }
+    GTEST_LOG_(INFO) << "CheckDouble002 End";
+}
+
+/**
+ * @tc.name: CheckDouble003
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, CheckDouble003, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "CheckDouble003 Start";
+    
+    try {
+        OHOS::FileManagement::CloudDisk::CheckDouble("");
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "CheckDouble003 ERROR";
+    }
+    GTEST_LOG_(INFO) << "CheckDouble003 End";
+}
+
 } // namespace OHOS::FileManagement::CloudDisk::Test
\ No newline at end of file
diff --git a/test/unittests/services_daemon/cloud_daemon_test.cpp b/test/unittests/services_daemon/cloud_daemon_test.cpp
index 2bb192508766350efe6bd4d702262e50c6621246..f4baaa7cc89c85410ce0d37b5aeb545f75d6b1c3 100644
--- a/test/unittests/services_daemon/cloud_daemon_test.cpp
+++ b/test/unittests/services_daemon/cloud_daemon_test.cpp
@@ -30,6 +30,7 @@ using namespace testing;
 using namespace testing::ext;
 constexpr int32_t USER_ID = 100;
 constexpr int32_t DEV_FD = 10;
+const string IO_MESSAGE_DIR = "/data/service/el1/public/cloudfile/io/";
 
 class CloudDaemonTest : public testing::Test {
 public:
@@ -134,6 +135,30 @@ HWTEST_F(CloudDaemonTest, OnStartTest2, TestSize.Level1)
     GTEST_LOG_(INFO) << "OnStart2 End";
 }
 
+/**
+ * @tc.name: OnStartTest3
+ * @tc.desc: Verify the OnStart function
+ * @tc.type: FUNC
+ * @tc.require: I6H5MH
+ */
+HWTEST_F(CloudDaemonTest, OnStartTest3, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "OnStart3 Start";
+    try {
+        cloudDaemon_->state_ = ServiceRunningState::STATE_NOT_START;
+        cloudDaemon_->registerToService_ = true;
+        if (filesystem::exists(IO_MESSAGE_DIR)) {
+            filesystem::remove(IO_MESSAGE_DIR);
+        }
+        cloudDaemon_->OnStart();
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "OnStart3  ERROR";
+    }
+    GTEST_LOG_(INFO) << "OnStart3 End";
+}
+
 /**
  * @tc.name: StartFuseTest001
  * @tc.desc: Verify the StartFuse function